using BuildingDirectory.Model;

namespace BuildingDirectory.Test;

public sealed class BuildingInformationTests
{
    private static readonly string[] companyNames = ["Foo Inc.", "Bar GmbH", "Baz AG"];
    private static readonly (BusinessCard Card, int Room)[] employees =
    [
        (new BusinessCard("A", "B", "Sales", null, "b@x.com"), 301),
        (new BusinessCard("A", "C", "Development", null, "c@x.com"), 444),
        (new BusinessCard("A", "D", "HR", null, "d@x.com"), 2),
        (new BusinessCard("A", "E", "Maintenance", null, "e@x.com"), 102)
    ];

    [Fact]
    public void GetFloorSelection()
    {
        var info = CreateSampleInfo();

        info.GetFloorSelection()
            .Should().NotBeNullOrEmpty()
            .And.HaveCount(2, "two floors defined")
            .And.Contain([Floor.Ground, Floor.First]);
    }

    [Fact]
    public void GetCompaniesOnFloor()
    {
        var info = CreateSampleInfo();

        info.GetCompaniesOnFloor(Floor.Ground)
            .Should().NotBeNullOrEmpty()
            .And.HaveCount(1, "only one company on this floor")
            .And.Contain([companyNames[1]]);
        info.GetCompaniesOnFloor(Floor.First)
            .Should().NotBeNullOrEmpty()
            .And.HaveCount(2, "two companies on this floor")
            .And.Contain([companyNames[0], companyNames[2]]);
        info.GetCompaniesOnFloor(Floor.Second)
            .Should().BeNull("no companies on this floor");
    }

    [Fact]
    public void GetCompany_Exists()
    {
        var info = CreateSampleInfo();

        var company1 = info.GetCompany(Floor.First, companyNames[0]);
        company1.Should().NotBeNull();
        company1!.Name.Should().Be(companyNames[0]);
        company1.NoOfEmployees.Should().Be(1);
        var company2 = info.GetCompany(Floor.Ground, companyNames[1]);
        company2.Should().NotBeNull();
        company2!.Name.Should().Be(companyNames[1]);
        company2.NoOfEmployees.Should().Be(2);
        var company3 = info.GetCompany(Floor.First, companyNames[2]);
        company3.Should().NotBeNull();
        company3!.Name.Should().Be(companyNames[2]);
        company3.NoOfEmployees.Should().Be(1);
    }
    
    [Fact]
    public void GetCompany_NotExists()
    {
        var info = CreateSampleInfo();

        info.GetCompany(Floor.Ground, companyNames[0])
            .Should().BeNull("company does not reside at this floor");
        info.GetCompany(Floor.Second, companyNames[2])
            .Should().BeNull("no companies on this floor");
    }

    private static BuildingInformation CreateSampleInfo()
    {
        var companiesGround = new MyDictionary<string, Company>();
        var companiesFirst = new MyDictionary<string, Company>();
        var employees1 = new MyDictionary<BusinessCard, int>();
        var employees2 = new MyDictionary<BusinessCard, int>();
        var employees3 = new MyDictionary<BusinessCard, int>();
        AddEmployee(employees1, 0);
        AddEmployee(employees2, 1);
        AddEmployee(employees2, 2);
        AddEmployee(employees3, 3);
        companiesFirst.Add(companyNames[0], new Company(employees1, companyNames[0]));
        companiesGround.Add(companyNames[1], new Company(employees2, companyNames[1]));
        companiesFirst.Add(companyNames[2], new Company(employees3, companyNames[2]));

        var floors = new MyDictionary<Floor, MyDictionary<string, Company>>();
        floors.Add(Floor.Ground, companiesGround);
        floors.Add(Floor.First, companiesFirst);

        return new BuildingInformation(floors);

        void AddEmployee(MyDictionary<BusinessCard, int> dic, int idx)
        {
            (var card, int room) = employees[idx];
            dic.Add(card, room);
        }
    }
}