namespace PS.IPAM.Tests.Models;

using FluentAssertions;
using PS.IPAM;
using Xunit;

public class SubnetworkTests
{
    [Fact]
    public void Constructor_SetsAllProperties()
    {
        // Arrange
        var id = 1;
        var subnet = "192.168.1.0";
        var mask = 24;
        var sectionId = 5;
        var description = "Production network";
        var linkedSubnet = "linked-123";
        var firewallObject = "FW_PROD";
        var vrfId = 2;
        var masterSubnetId = 0;
        var allowRequests = true;
        var vlanId = 100;
        var showName = true;
        var deviceId = 10;
        var permissions = "rw";
        var pingSubnet = true;
        var discoverSubnet = false;
        var resolveDNS = true;
        var dnsRecursive = false;
        var dnsRecords = true;
        var nameserverId = 3;
        var scanAgent = false;
        var isFolder = false;
        var isFull = false;
        var isPool = true;
        var tagId = 1;
        var threshold = 80;
        var locationId = 4;
        var editDate = new DateTime(2026, 1, 10);
        var lastScan = new DateTime(2026, 1, 9);
        var lastDiscovery = new DateTime(2026, 1, 8);
        var calculation = new { maxhosts = 254 };
        var customFields = new Dictionary<string, object> { { "custom_env", "prod" } };

        // Act
        var subnetwork = new Subnetwork(
            id, subnet, mask, sectionId, description, linkedSubnet, firewallObject,
            vrfId, masterSubnetId, allowRequests, vlanId, showName, deviceId,
            permissions, pingSubnet, discoverSubnet, resolveDNS, dnsRecursive,
            dnsRecords, nameserverId, scanAgent, isFolder, isFull, isPool,
            tagId, threshold, locationId, editDate, lastScan, lastDiscovery,
            calculation, customFields
        );

        // Assert
        subnetwork.Id.Should().Be(id);
        subnetwork.Subnet.Should().Be(subnet);
        subnetwork.Mask.Should().Be(mask);
        subnetwork.SectionId.Should().Be(sectionId);
        subnetwork.Description.Should().Be(description);
        subnetwork.LinkedSubnet.Should().Be(linkedSubnet);
        subnetwork.FirewallAddressObject.Should().Be(firewallObject);
        subnetwork.VrfId.Should().Be(vrfId);
        subnetwork.MasterSubnetId.Should().Be(masterSubnetId);
        subnetwork.AllowRequests.Should().Be(allowRequests);
        subnetwork.VlanId.Should().Be(vlanId);
        subnetwork.ShowName.Should().Be(showName);
        subnetwork.DeviceId.Should().Be(deviceId);
        subnetwork.Permissions.Should().Be(permissions);
        subnetwork.PingSubnet.Should().Be(pingSubnet);
        subnetwork.DiscoverSubnet.Should().Be(discoverSubnet);
        subnetwork.ResolveDNS.Should().Be(resolveDNS);
        subnetwork.DNSRecursive.Should().Be(dnsRecursive);
        subnetwork.DNSRecords.Should().Be(dnsRecords);
        subnetwork.NameserverId.Should().Be(nameserverId);
        subnetwork.ScanAgent.Should().Be(scanAgent);
        subnetwork.IsFolder.Should().Be(isFolder);
        subnetwork.IsFull.Should().Be(isFull);
        subnetwork.IsPool.Should().Be(isPool);
        subnetwork.TagId.Should().Be(tagId);
        subnetwork.Threshold.Should().Be(threshold);
        subnetwork.LocationId.Should().Be(locationId);
        subnetwork.EditDate.Should().Be(editDate);
        subnetwork.LastScan.Should().Be(lastScan);
        subnetwork.LastDiscovery.Should().Be(lastDiscovery);
        subnetwork.Calculation.Should().BeEquivalentTo(calculation);
        subnetwork.ExtendedData.Should().BeEquivalentTo(customFields);
    }

    [Theory]
    [InlineData("192.168.1.0", 24, "192.168.1.0/24")]
    [InlineData("10.0.0.0", 8, "10.0.0.0/8")]
    [InlineData("172.16.0.0", 16, "172.16.0.0/16")]
    [InlineData("192.168.100.0", 30, "192.168.100.0/30")]
    public void CIDR_ReturnsCidrNotation(string subnet, int mask, string expectedCidr)
    {
        // Arrange
        var subnetwork = CreateSubnetwork(subnet, mask);

        // Act
        var result = subnetwork.CIDR;

        // Assert
        result.Should().Be(expectedCidr);
    }

    [Fact]
    public void ToString_ReturnsCidrNotation()
    {
        // Arrange
        var subnetwork = CreateSubnetwork("10.10.0.0", 16);

        // Act
        var result = subnetwork.ToString();

        // Assert
        result.Should().Be("10.10.0.0/16");
    }

    [Fact]
    public void ToString_EqualsCIDRProperty()
    {
        // Arrange
        var subnetwork = CreateSubnetwork("172.20.0.0", 12);

        // Act & Assert
        subnetwork.ToString().Should().Be(subnetwork.CIDR);
    }

    [Fact]
    public void Record_Equality_WorksCorrectly()
    {
        // Arrange - use same calculation object for equality comparison
        var calculation = new { maxhosts = 254 };
        var subnet1 = CreateSubnetwork("192.168.1.0", 24, calculation);
        var subnet2 = CreateSubnetwork("192.168.1.0", 24, calculation);

        // Assert - records use value equality (except for the Calculation object reference)
        subnet1.Id.Should().Be(subnet2.Id);
        subnet1.Subnet.Should().Be(subnet2.Subnet);
        subnet1.Mask.Should().Be(subnet2.Mask);
        subnet1.CIDR.Should().Be(subnet2.CIDR);
    }

    private static Subnetwork CreateSubnetwork(string subnet, int mask, object? calculation = null)
    {
        return new Subnetwork(
            1, subnet, mask, 1, "", "", "",
            0, 0, false, 0, false, 0,
            "", false, false, false, false,
            false, 0, false, false, false, false,
            0, 0, 0, null, null, null,
            calculation ?? new object(), null
        );
    }
}