using System;
using System.Collections.Generic;
using System.Linq;
using FluentAssertions;
using Moq;
using SharpCompress.Common;
using Xrm.Rec.DataLayer.Entities.Account;
using Xrm.Rec.DataLayer.Entities.Catalog;
using Xrm.Rec.DataLayer.Entities.DisclosureControl;
using Xrm.Rec.DataLayer.Entities.RegulatedOrganizationsPrograms;
using Xrm.Rec.DataLayer.Entities.RegulatedOrganizationsPrograms.Catalog;
using Xrm.Rec.DataLayer.Entities.RegulatorMeetings;
using Xrm.Rec.DataLayer.Entities.Tariff;
using Xrm.Rec.DataLayer.Repositories.Interfaces;
using Xrm.Rec.Domain.Common.ConstantMapping;
using Xrm.Rec.Domain.Common.Enums.CatalogModule;
using Xrm.Rec.Domain.Services.Catalogs;
using Xrm.Rec.Domain.Services.Catalogs.Dto;
using Xrm.Rec.Domain.Services.Catalogs.Interfaces;
using Xrm.Rec.Domain.Services.Shared.Dto;
using Xrm.Rec.UnitTests.Common;
using Xrm.Rec.UnitTests.Common.DataMocks;
using Xunit;
using Xrm.Rec.Domain.Services.Exceptions;
using Xrm.Universal.DataLayer.Interfaces;
using Xrm.Universal.EventBus.Interfaces;
using Xrm.Universal.Models;

namespace Xrm.Rec.Domain.Services.UnitTests.Catalogs
{
    public class DomainWorkKindServiceTests : TestBase
    {
        private readonly RepositoryManagerStub _repositoryManagerStub;
        private readonly IDomainWorkKindService _domainWorkKindService;

        private ICommonRepository<DbWorkKind> WorkKindRepository => _repositoryManagerStub.GetCommonRepository<DbWorkKind>();
        private readonly Mock<IWorkKindMapper> _workKindMapperMock;

        public DomainWorkKindServiceTests()
        {
            _workKindMapperMock = new Mock<IWorkKindMapper>(MockBehavior.Strict);
            _repositoryManagerStub = new RepositoryManagerStub();
            _domainWorkKindService = new DomainWorkKindService(_repositoryManagerStub, Mock.Of<IEventBus>(), _workKindMapperMock.Object);
        }


        #region Search

        public static TheoryData<Action<RepositoryManagerStub>> AddRepositoryForSearchData()
        {
            var data = new TheoryData<Action<RepositoryManagerStub>>
            {
                (r) => r.SetDbEntities(new DbEseeProgramRequirement { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbInvestProgramFinancingSource { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbMonitoring2WorkKind { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbImplementedWorkKind { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbEseeProgramRequirement { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbInvestProgramFinancingSource { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbPublicationDocument2WorkKind { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbReport { Report2WorkKinds = new List<DbReport2WorkKind> { new DbReport2WorkKind { WorkKindId = 3 } } }),
                (r) => r.SetDbEntities(new DbEseeProgram { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbInvestProgram { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbProgram2WorkKind { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbQuestionVersion { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbDifferentiationCriterium { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbSci { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbTariff { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbTariffKind { WorkKindId = 3 })
            };
            return data;
        }

        [Theory]
        [MemberData(nameof(AddRepositoryForSearchData))]
        public void SearchCanDelete(Action<RepositoryManagerStub> repoAction)
        {
            _repositoryManagerStub.SetDbEntities(new DbWorkKind { Id = 3, Group = new DbWorkKindGroup() { Id = 3, Description = "grp" } });
            repoAction(_repositoryManagerStub);

            var result = _domainWorkKindService.Search();
            result.Single().CanDelete.Should().BeFalse();
        }

        [Fact]
        public void Search()
        {
            _repositoryManagerStub.SetDbEntities(
                new DbWorkKind { Id = 1, Code = 1, Name = "WorkKind_1", Group = new DbWorkKindGroup { Id = 1, Description = "WorkKindGroup_1" }, RegulationStartDate = new DateTime(2001, 01, 01), RegulationEndDate = new DateTime(2001, 12, 31) },
                new DbWorkKind { Id = 2, Code = 2, Name = "WorkKind_2", Group = new DbWorkKindGroup { Id = 2, Description = "WorkKindGroup_2" }, RegulationStartDate = new DateTime(2002, 01, 01), RegulationEndDate = new DateTime(2002, 12, 31) },
                new DbWorkKind { Id = 3, Code = 3, Name = "WorkKind_3", Group = new DbWorkKindGroup { Id = 3, Description = "WorkKindGroup_3" }, RegulationStartDate = new DateTime(2003, 01, 01) },
                new DbWorkKind { Id = 4, Code = 4, Name = "WorkKind_4", Group = new DbWorkKindGroup { Id = 4, Description = "WorkKindGroup_4" }, RegulationStartDate = new DateTime(2004, 01, 01) }
            );

            var result = _domainWorkKindService.Search();
            result.ShouldBeEquivalentTo(new[]
            {
                new WorkKindRegistryItem { Id = 1, Code = 1, Name = "WorkKind_1", WorkKindGroup = new IdNamePair { Name = "WorkKindGroup_1" }, RegulationInterval = new DateTimeIntervalDto() { Start = new DateTime(2001, 01, 01), Finish = new DateTime(2001, 12, 31) }, CanDelete = true },
                new WorkKindRegistryItem { Id = 2, Code = 2, Name = "WorkKind_2", WorkKindGroup = new IdNamePair { Name = "WorkKindGroup_2" }, RegulationInterval = new DateTimeIntervalDto() { Start = new DateTime(2002, 01, 01), Finish = new DateTime(2002, 12, 31) }, CanDelete = true },
                new WorkKindRegistryItem { Id = 3, Code = 3, Name = "WorkKind_3", WorkKindGroup = new IdNamePair { Name = "WorkKindGroup_3" }, RegulationInterval = new DateTimeIntervalDto() { Start = new DateTime(2003, 01, 01) }, CanDelete = true },
                new WorkKindRegistryItem { Id = 4, Code = 4, Name = "WorkKind_4", WorkKindGroup = new IdNamePair { Name = "WorkKindGroup_4" }, RegulationInterval = new DateTimeIntervalDto() { Start = new DateTime(2004, 01, 01) }, CanDelete = true }
            });
        }

        #endregion

        #region Get


        [Fact]
        public void GetThrow()
        {
            _repositoryManagerStub.SetDbEntities(
                new DbWorkKind { Id = 1, Code = 1, Name = "WorkKind_1", Group = new DbWorkKindGroup { Id = 1, Description = "WorkKindGroup_1" }, RegulationStartDate = new DateTime(2001, 01, 01), RegulationEndDate = new DateTime(2001, 12, 31) }
            );

            Action action = () => _domainWorkKindService.Get(555);
            action.ShouldThrow<ServiceException>()
                .Which
                .ServiceExceptionType.ShouldBeEquivalentTo(ServiceExceptionTypes.EntityNotFound);
        }

        [Fact]
        public void Get()
        {
            _repositoryManagerStub.SetDbEntities(
                new DbWorkKind { Id = 1, Code = 1, Name = "WorkKind_1", Group = new DbWorkKindGroup { Id = 1, Description = "WorkKindGroup_1" }, RegulationStartDate = new DateTime(2001, 01, 01), RegulationEndDate = new DateTime(2001, 12, 31) }
            );

            _workKindMapperMock.Setup(x => x.Map(It.IsAny<DbWorkKind>())).Returns(new WorkKindDto());
            _domainWorkKindService.Get(1);

            _workKindMapperMock.VerifyAll();
        }

        [Fact]
        public void GetWorkKindGroups()
        {
            _repositoryManagerStub.SetDbEntities(
                new DbWorkKindGroup { Id = 1, Description = "grp1" },
                new DbWorkKindGroup { Id = 2, Description = "grp2" },
                new DbWorkKindGroup { Id = 3, Description = "grp3" }
            );

            var rezult = _domainWorkKindService.GetWorkKindGroups();
            rezult.ShouldBeEquivalentTo(new[]
            {
                new IdNamePair { Id = 1, Name = "grp1" },
                new IdNamePair { Id = 2, Name = "grp2" },
                new IdNamePair { Id = 3, Name = "grp3" },
            });
        }

        [Fact]
        public void GetWorkKindItems()
        {
            var group1 = new DbWorkKindGroup { Id = WorkKindGroup.Transportation.GetId(), Description = WorkKindGroup.Transportation.GetDescription() };
            var group2 = new DbWorkKindGroup { Id = WorkKindGroup.Other.GetId(), Description = WorkKindGroup.Other.GetDescription() };

            _repositoryManagerStub.SetDbEntities(
                new DbWorkKind { Id = 3, Name = "Name_3", Group = group2 },
                new DbWorkKind { Id = 2, Name = "Name_2", Group = group1 },
                new DbWorkKind { Id = 1, Name = "Name_1", Group = group1 }
            );

            var result = _domainWorkKindService.GetWorkKindItems();

            result.ShouldBeEquivalentTo(new[]
            {
                new WorkKindGroupItemDto
                {
                    Id = WorkKindGroup.Other.GetId(),
                    Name = WorkKindGroup.Other.GetDescription(),
                    Items = new List<IdNamePair>
                    {
                        new IdNamePair { Id = 3, Name = "Name_3" }
                    }
                },
                new WorkKindGroupItemDto
                {
                    Id = WorkKindGroup.Transportation.GetId(),
                    Name = WorkKindGroup.Transportation.GetDescription(),
                    Items = new List<IdNamePair>
                    {
                        new IdNamePair { Id = 1, Name = "Name_1" },
                        new IdNamePair { Id = 2, Name = "Name_2" }
                    }
                }
            });
        }

        #endregion

        #region Edit

        [Fact]
        public void AddThrows()
        {
            _repositoryManagerStub.SetDbEntities(new DbWorkKind { Id = 1, Code = 1, Name = "Name_1" });

            var dto = new WorkKindDto { Name = "Name_1" };

            Action action = () => _domainWorkKindService.Edit(dto);
            action.ShouldThrow<ServiceException>()
                .WithMessage("Вид деятельности с таким наименованием уже существует в реестре")
                .Which
                .ServiceExceptionType.ShouldBeEquivalentTo(ServiceExceptionTypes.InvalidInputData);
        }

        [Fact]
        public void Add()
        {
            _repositoryManagerStub.SetDbEntities(new DbWorkKind { Id = 1, Code = 1, Name = "Name_1" });

            var dto = new WorkKindDto
            {
                Name = "Name_2",
                WorkKindGroup = new IdNamePair { Id = WorkKindGroup.Other.GetId() },
                RegulationInterval = new DateTimeIntervalDto
                {
                    Start = new DateTime(2004, 04, 04),
                    Finish = new DateTime(2005, 05, 05),
                }
            };
            _workKindMapperMock.Setup(x => x.Update(It.IsAny<DbWorkKind>(), It.IsAny<WorkKindDto>()));
            _workKindMapperMock.Setup(x => x.Map(It.IsAny<DbWorkKind>())).Returns(new WorkKindDto());

            _domainWorkKindService.Edit(dto);

            _workKindMapperMock.VerifyAll();
        }

        [Fact]
        public void EditNameException()
        {
            _repositoryManagerStub.SetDbEntities(
                new DbWorkKind { Id = 1, Code = 1, Name = "Name_1" },
                new DbWorkKind { Id = 2, Code = 2, Name = "Name_2" }
            );

            var dto = new WorkKindDto
            {
                Name = "Name_2",
                WorkKindGroup = new IdNamePair { Id = WorkKindGroup.Other.GetId() },
                RegulationInterval = new DateTimeIntervalDto
                {
                    Start = new DateTime(2004, 04, 04),
                    Finish = new DateTime(2005, 05, 05),
                }
            };

            Action action = () => _domainWorkKindService.Edit(dto);
            action.ShouldThrow<ServiceException>()
                .WithMessage("Вид деятельности с таким наименованием уже существует в реестре")
                .Which
                .ServiceExceptionType.ShouldBeEquivalentTo(ServiceExceptionTypes.InvalidInputData);

        }

        [Fact]
        public void EditMyName()
        {
            _repositoryManagerStub.SetDbEntities(
                new DbWorkKind { Id = 1, Code = 1, Name = "Name_1" },
                new DbWorkKind { Id = 2, Code = 2, Name = "Name_2" }
            );

            var dto = new WorkKindDto
            {
                Id = 2,
                Name = "Name_2",
                WorkKindGroup = new IdNamePair { Id = WorkKindGroup.Other.GetId() },
                RegulationInterval = new DateTimeIntervalDto
                {
                    Start = new DateTime(2004, 04, 04),
                    Finish = new DateTime(2005, 05, 05),
                }
            };
            _workKindMapperMock.Setup(x => x.Map(It.IsAny<DbWorkKind>())).Returns(new WorkKindDto());
            _workKindMapperMock.Setup(x => x.Update(It.IsAny<DbWorkKind>(), It.IsAny<WorkKindDto>()));

            _domainWorkKindService.Edit(dto);

            _workKindMapperMock.VerifyAll();
        }

        [Fact]
        public void Edit()
        {
            _repositoryManagerStub.SetDbEntities(
                new DbWorkKind { Id = 1, Code = 1, Name = "Name_1" },
                new DbWorkKind { Id = 2, Code = 2, Name = "Name_2" }
            );

            var dto = new WorkKindDto
            {
                Id = 2,
                Name = "Name_2_2",
                WorkKindGroup = new IdNamePair { Id = WorkKindGroup.Other.GetId() },
                RegulationInterval = new DateTimeIntervalDto
                {
                    Start = new DateTime(2004, 04, 04),
                    Finish = new DateTime(2005, 05, 05),
                }
            };
            _workKindMapperMock.Setup(x => x.Map(It.IsAny<DbWorkKind>())).Returns(new WorkKindDto());
            _workKindMapperMock.Setup(x => x.Update(It.IsAny<DbWorkKind>(), It.IsAny<WorkKindDto>()));

            _domainWorkKindService.Edit(dto);

            _workKindMapperMock.VerifyAll();
        }

        #endregion

        #region Actions

        [Fact]
        public void Delete()
        {
            _repositoryManagerStub.SetDbEntities(new DbWorkKind { Id = 1 });
            var workKindRepository = _repositoryManagerStub.GetCommonRepository<DbWorkKind>();

            _workKindMapperMock.Setup(x => x.Map(It.IsAny<DbWorkKind>())).Returns(new WorkKindDto());
            workKindRepository.Find().Should().HaveCount(1);

            _domainWorkKindService.Delete(1);
            workKindRepository.Find().Should().BeEmpty();
            _workKindMapperMock.VerifyAll();
        }

        public static TheoryData<Action<RepositoryManagerStub>> AddRepositoryData()
        {
            var data = new TheoryData<Action<RepositoryManagerStub>>
            {
                (r) => r.SetDbEntities(new DbEseeProgramRequirement { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbInvestProgramFinancingSource { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbMonitoring2WorkKind { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbImplementedWorkKind { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbEseeProgramRequirement { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbInvestProgramFinancingSource { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbPublicationDocument2WorkKind { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbReport { Report2WorkKinds = new List<DbReport2WorkKind> { new DbReport2WorkKind { WorkKindId = 3 } } }),
                (r) => r.SetDbEntities(new DbEseeProgram { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbInvestProgram { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbProgram2WorkKind { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbQuestionVersion { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbDifferentiationCriterium { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbSci { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbTariff { WorkKindId = 3 }),
                (r) => r.SetDbEntities(new DbTariffKind { WorkKindId = 3 })
            };
            return data;
        }

        [Theory]
        [MemberData(nameof(AddRepositoryData))]
        public void DeleteThrow(Action<RepositoryManagerStub> repoAction)
        {
            _repositoryManagerStub.SetDbEntities(new DbWorkKind { Id = 3 });
            repoAction(_repositoryManagerStub);

            Action action = () => _domainWorkKindService.Delete(3);

            action.ShouldThrow<ServiceException>()
                .Which
                .ServiceExceptionType.ShouldBeEquivalentTo(ServiceExceptionTypes.ValidationError);
        }

        #endregion
    }
}