using System;
using System.Collections.Generic;
using System.Linq;
using LCU.API.Collections.CollectionsApiLib.Models;
using LCU.API.Collections.RepoApi.Configuration;
using LCU.API.Collections.RepoApi.DataAccess;
using LCU.API.Collections.RepoApi.Services;
using LCU.Shared.Collections.RepoApiLib.Models;
using LCU.Shared.Collections.RepoApiLib.Models.Settings;
using LCU.Shared.Collections.RepoApiLib.Repositories;
using LCU.Shared.Collections.RepoApiLib.Repositories.Settings;
using Microsoft.Extensions.Caching.Memory;
using Moq;
using Xunit;

namespace LCU.API.Collections.RepoApiTests.Services
{
    public class SettingsServiceTest
    {
        private Mock<IAccountTypeRepository> _mockAccountTypeRepository;
        private Mock<IAllowedStatusChangeRepository> _mockAllowedStatusChangeRepository;
        private Mock<IBodyStyleRepository> _mockBodyStyleRepository;
        private Mock<ICleaningLevelRepository> _mockCleaningLevelRepository;
        private Mock<ICollateralTypeRepository> _mockCollateralTypeRepository;
        private Mock<ICollateralTypeToVehicleTypeRepository> _mockCollateralTypeToVehicleTypeRepository;
        private Mock<IHoldStatusRepository> _mockHoldStatusRepository;
        private Mock<ILoanCategoryRepository> _mockLoanCategoryRepository;
        private Mock<ILocationTypeRepository> _mockLocationTypeRepository;
        private Mock<IVehicleTypeRepository> _mockVehicleTypeRepository;
        private Mock<IExternalUserRepository> _mockExternalUserRepository;
        private Mock<IRepoCompanyRepository> _mockRepoCompanyRepository;
        private Mock<ICollectionsDao> _mockCollectionsDao;
        private Mock<IUnitOfWork> _mockUnitOfWork;
        private Mock<IMemoryCache> _memoryCache;
        private RepoApiConfiguration _configuration;

        private List<AccountType> accountTypes = new List<AccountType>
        {
            new AccountType()
        };

        private List<AllowedStatusChange> allowedStatusChanges = new List<AllowedStatusChange>
        {
            new AllowedStatusChange()
        };

        private List<BodyStyle> bodyStyles = new List<BodyStyle>
        {
            new BodyStyle()
        };

        List<CleaningLevel> cleaningLevels = new List<CleaningLevel>
        {
            new CleaningLevel()
        };

        private List<CollateralType> collateralTypes = new List<CollateralType>
        {
            new CollateralType()
        };


        private List<CollateralTypeToVehicleType> collateralTypeToVehicleTypes = new List<CollateralTypeToVehicleType>
        {
            new CollateralTypeToVehicleType()
        };

        private List<HoldStatus> holdStatuses = new List<HoldStatus>
        {
            new HoldStatus()
        };

        private List<LoanCategory> loanCategories = new List<LoanCategory>
        {
            new LoanCategory()
        };

        private List<LocationType> locationTypes = new List<LocationType>
        {
            new LocationType()
        };

        private List<VehicleType> vehicleTypes = new List<VehicleType>
        {
            new VehicleType()
        };

        private List<BranchEntry> branchSet = new List<BranchEntry>
        {
            new BranchEntry() { BranchId = "5", BranchName = "Mars" }
        };

        private List<ExternalUser> externalUserSet = new List<ExternalUser>
        {
            new ExternalUser() { Id = 10, Code = "jdoe", Name = "John Doe" }
        };

        private List<RepoCompany> RepoCompanies = new List<RepoCompany>
        {
            new RepoCompany() { ID = 5, ReferenceId = 555 }
        };

        private readonly List<string> _transactionTypeCodes = new List<string> { "TEST" };
        private readonly string _transactionTypeCodeQueryPrefix = "TESTPREFIX";
        private readonly string _transactionHistoryParameterDateFormat = "yyyy-MM-dd";
        private readonly int _transactionHistoryStartDateOffset = 120;

        public SettingsServiceTest()
        {
            _mockAccountTypeRepository = new Mock<IAccountTypeRepository>();
            _mockAllowedStatusChangeRepository = new Mock<IAllowedStatusChangeRepository>();
            _mockBodyStyleRepository = new Mock<IBodyStyleRepository>();
            _mockCleaningLevelRepository = new Mock<ICleaningLevelRepository>();
            _mockCollateralTypeRepository = new Mock<ICollateralTypeRepository>();
            _mockCollateralTypeToVehicleTypeRepository = new Mock<ICollateralTypeToVehicleTypeRepository>();
            _mockHoldStatusRepository = new Mock<IHoldStatusRepository>();
            _mockLoanCategoryRepository = new Mock<ILoanCategoryRepository>();
            _mockLocationTypeRepository = new Mock<ILocationTypeRepository>();
            _mockVehicleTypeRepository = new Mock<IVehicleTypeRepository>();
            _mockExternalUserRepository = new Mock<IExternalUserRepository>();
            _mockRepoCompanyRepository = new Mock<IRepoCompanyRepository>();
            _mockCollectionsDao = new Mock<ICollectionsDao>();
            _mockUnitOfWork = new Mock<IUnitOfWork>();
            _memoryCache = new Mock<IMemoryCache>();
            _configuration = new RepoApiConfiguration
            {
                TransactionTypeCodes = _transactionTypeCodes,
                TransactionTypeCodeQueryPrefix = _transactionTypeCodeQueryPrefix,
                TransactionHistoryParameterDateFormat = _transactionHistoryParameterDateFormat,
                TransactionHistoryStartDateOffset = _transactionHistoryStartDateOffset
            };

            _mockAccountTypeRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(accountTypes);
            _mockAllowedStatusChangeRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(allowedStatusChanges);
            _mockBodyStyleRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(bodyStyles);
            _mockCleaningLevelRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(cleaningLevels);
            _mockCollateralTypeRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(collateralTypes);
            _mockCollateralTypeToVehicleTypeRepository.Setup(x => x.ListAllAsync())
                .ReturnsAsync(collateralTypeToVehicleTypes);
            _mockHoldStatusRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(holdStatuses);
            _mockLoanCategoryRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(loanCategories);
            _mockLocationTypeRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(locationTypes);
            _mockVehicleTypeRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(vehicleTypes);
            _mockExternalUserRepository.Setup(x => x.ListAsync()).ReturnsAsync(externalUserSet);
            _mockRepoCompanyRepository.Setup(x => x.ListAsync()).ReturnsAsync(RepoCompanies);
            _mockCollectionsDao.Setup(x => x.RetrieveBranchSetAsync()).ReturnsAsync(branchSet);
        }

        private SettingsService BuildTestSettingsService()
        {
            return new SettingsService
            (
                _mockAccountTypeRepository.Object,
                _mockAllowedStatusChangeRepository.Object,
                _mockBodyStyleRepository.Object,
                _mockCleaningLevelRepository.Object,
                _mockCollateralTypeRepository.Object,
                _mockCollateralTypeToVehicleTypeRepository.Object,
                _mockHoldStatusRepository.Object,
                _mockLoanCategoryRepository.Object,
                _mockLocationTypeRepository.Object,
                _mockVehicleTypeRepository.Object,
                _mockExternalUserRepository.Object,
                _mockRepoCompanyRepository.Object,
                _mockUnitOfWork.Object,
                _memoryCache.Object,
                _mockCollectionsDao.Object,
                _configuration
            );
        }

        [Fact]
        public async void ListSettings_Ok()
        {
            // arrange service instance
            var service = BuildTestSettingsService();

            // act
            var result = await service.ListAllSettingsAsync();

            // assert
            Assert.NotNull(result);

            Assert.Single(result.AccountTypes);
            Assert.True(accountTypes.SequenceEqual(result.AccountTypes));

            Assert.Single(result.AllowedStatusChanges);
            Assert.True(allowedStatusChanges.SequenceEqual(result.AllowedStatusChanges));

            Assert.Single(result.BodyStyles);
            Assert.True(bodyStyles.SequenceEqual(result.BodyStyles));

            Assert.Single(result.CleaningLevels);
            Assert.True(cleaningLevels.SequenceEqual(result.CleaningLevels));

            Assert.Single(result.CollateralTypes);
            Assert.True(collateralTypes.SequenceEqual(result.CollateralTypes));

            Assert.Single(result.CollateralTypesToVehicleTypes);
            Assert.True(collateralTypeToVehicleTypes.SequenceEqual(result.CollateralTypesToVehicleTypes));

            Assert.Single(result.HoldStatuses);
            Assert.True(holdStatuses.SequenceEqual(result.HoldStatuses));

            Assert.Single(result.LoanCategories);
            Assert.True(loanCategories.SequenceEqual(result.LoanCategories));

            Assert.Single(result.LocationTypes);
            Assert.True(locationTypes.SequenceEqual(result.LocationTypes));

            Assert.Single(result.VehicleTypes);
            Assert.True(vehicleTypes.SequenceEqual(result.VehicleTypes));

            Assert.Single(result.BranchSet);
            Assert.True(branchSet.SequenceEqual(result.BranchSet));

            Assert.Single(result.RepoCompanies);
            Assert.True(RepoCompanies.SequenceEqual(result.RepoCompanies));
            
            Assert.Single(result.TransactionTypeCodes);
            Assert.True(_transactionTypeCodes.SequenceEqual(result.TransactionTypeCodes));
            
            Assert.Equal(_transactionHistoryParameterDateFormat.ToUpper(), result.TransactionHistoryParameterDateFormat);
            
            Assert.Equal(_transactionTypeCodeQueryPrefix, result.TransactionTypeCodeQueryPrefix);
            
            Assert.Equal(_transactionHistoryStartDateOffset, result.TransactionHistoryStartDateOffset);

            Assert.NotNull((result.RepoTypeMap));
            Assert.Equal(5, result.RepoTypeMap.Count);
            Assert.Equal(RepoType.Involuntary.ToString(), result.RepoTypeMap.GetValueOrDefault((int)RepoType.Involuntary));
            Assert.Equal(RepoType.Voluntary.ToString(), result.RepoTypeMap.GetValueOrDefault((int)RepoType.Voluntary));
            Assert.Equal(RepoType.Skip.ToString(), result.RepoTypeMap.GetValueOrDefault((int)RepoType.Skip));
            Assert.Equal(RepoType.PreSkip.ToString(), result.RepoTypeMap.GetValueOrDefault((int)RepoType.PreSkip));
            Assert.Equal(RepoType.Unknown.ToString(), result.RepoTypeMap.GetValueOrDefault((int)RepoType.Unknown));
        }

        [Fact]
        public async void Save_Account_Type_OK()
        {
            var type = new AccountType();
            _mockAccountTypeRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(new List<AccountType> { type });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(type);

            // assert
            Assert.NotNull(result);
            Assert.Equal(type, result);
        }

        [Fact]
        public async void Save_Allowed_Status_Change_OK()
        {
            var statusChange = new AllowedStatusChange();
            _mockAllowedStatusChangeRepository.Setup(x => x.ListAllAsync())
                .ReturnsAsync(new List<AllowedStatusChange> { statusChange });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(statusChange);

            // assert
            Assert.NotNull(result);
            Assert.Equal(statusChange, result);
        }

        [Fact]
        public async void Save_Body_Style_OK()
        {
            var bodyStyle = new BodyStyle();
            _mockBodyStyleRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(new List<BodyStyle> { bodyStyle });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(bodyStyle);

            // assert
            Assert.NotNull(result);
            Assert.Equal(bodyStyle, result);
        }

        [Fact]
        public async void Save_Cleaning_Level_OK()
        {
            var cleaningLevel = new CleaningLevel();
            _mockCleaningLevelRepository.Setup(x => x.ListAllAsync())
                .ReturnsAsync(new List<CleaningLevel> { cleaningLevel });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(cleaningLevel);

            // assert
            Assert.NotNull(result);
            Assert.Equal(cleaningLevel, result);
        }

        [Fact]
        public async void Save_Collateral_Type_OK()
        {
            var collateralType = new CollateralType();
            _mockCollateralTypeRepository.Setup(x => x.ListAllAsync())
                .ReturnsAsync(new List<CollateralType> { collateralType });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(collateralType);

            // assert
            Assert.NotNull(result);
            Assert.Equal(collateralType, result);
        }

        [Fact]
        public async void Save_Collateral_Type_To_Vehicle_Type_OK()
        {
            var collateralToVehicle = new CollateralTypeToVehicleType();
            _mockCollateralTypeToVehicleTypeRepository.Setup(x => x.ListAllAsync())
                .ReturnsAsync(new List<CollateralTypeToVehicleType> { collateralToVehicle });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(collateralToVehicle);

            // assert
            Assert.NotNull(result);
            Assert.Equal(collateralToVehicle, result);
        }

        [Fact]
        public async void Save_Hold_Status_OK()
        {
            var holdStatus = new HoldStatus();
            _mockHoldStatusRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(new List<HoldStatus> { holdStatus });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(holdStatus);

            // assert
            Assert.NotNull(result);
            Assert.Equal(holdStatus, result);
        }

        [Fact]
        public async void Save_Loan_Category_OK()
        {
            var loanCategory = new LoanCategory();
            _mockLoanCategoryRepository.Setup(x => x.ListAllAsync())
                .ReturnsAsync(new List<LoanCategory> { loanCategory });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(loanCategory);

            // assert
            Assert.NotNull(result);
            Assert.Equal(loanCategory, result);
        }

        [Fact]
        public async void Save_Location_Type_OK()
        {
            var locationType = new LocationType();
            _mockLocationTypeRepository.Setup(x => x.ListAllAsync())
                .ReturnsAsync(new List<LocationType> { locationType });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(locationType);

            // assert
            Assert.NotNull(result);
            Assert.Equal(locationType, result);
        }

        [Fact]
        public async void Save_Vehicle_Type_OK()
        {
            var vehicleType = new VehicleType();
            _mockVehicleTypeRepository.Setup(x => x.ListAllAsync()).ReturnsAsync(new List<VehicleType> { vehicleType });

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.SaveAsync(vehicleType);

            // assert
            Assert.NotNull(result);
            Assert.Equal(vehicleType, result);
        }

        [Fact]
        public async void Update_Account_Type_OK()
        {
            var type = new AccountType();
            _mockAccountTypeRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(type);
            type.Description = "New description";

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(type);

            // assert
            Assert.NotNull(result);
            Assert.Equal("New description", result.Description);
        }

        [Fact]
        public async void Update_Allowed_Status_Change_OK()
        {
            var statusChange = new AllowedStatusChange();
            _mockAllowedStatusChangeRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(statusChange);
            statusChange.AllowedChangeStatus = "New status";

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(statusChange);

            // assert
            Assert.NotNull(result);
            Assert.Equal("New status", result.AllowedChangeStatus);
        }

        [Fact]
        public async void Update_Body_Style_OK()
        {
            var bodyStyle = new BodyStyle();
            _mockBodyStyleRepository.Setup(x => x.FindByIdAsync(It.IsAny<string>())).ReturnsAsync(bodyStyle);
            bodyStyle.Description = "New description";

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(bodyStyle);

            // assert
            Assert.NotNull(result);
            Assert.Equal("New description", result.Description);
        }

        [Fact]
        public async void Update_Cleaning_Level_OK()
        {
            var cleaningLevel = new CleaningLevel();
            _mockCleaningLevelRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(cleaningLevel);
            cleaningLevel.Description = "New description";

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(cleaningLevel);

            // assert
            Assert.NotNull(result);
            Assert.Equal("New description", result.Description);
        }

        [Fact]
        public async void Update_Collateral_Type_OK()
        {
            var collateralType = new CollateralType();
            _mockCollateralTypeRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(collateralType);
            collateralType.Description = "New description";

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(collateralType);

            // assert
            Assert.NotNull(result);
            Assert.Equal("New description", result.Description);
        }

        [Fact]
        public async void Update_Collateral_Type_To_Vehicle_Type_OK()
        {
            var collateralToVehicle = new CollateralTypeToVehicleType();
            _mockCollateralTypeToVehicleTypeRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>()))
                .ReturnsAsync(collateralToVehicle);
            collateralToVehicle.VehicleTypeId = 42;

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(collateralToVehicle);

            // assert
            Assert.NotNull(result);
            Assert.Equal(42, result.VehicleTypeId);
        }

        [Fact]
        public async void Update_Hold_Status_OK()
        {
            var holdStatus = new HoldStatus();
            _mockHoldStatusRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(holdStatus);
            holdStatus.Description = "New description";

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(holdStatus);

            // assert
            Assert.NotNull(result);
            Assert.Equal("New description", result.Description);
        }

        [Fact]
        public async void Update_Loan_Category_OK()
        {
            var loanCategory = new LoanCategory();
            _mockLoanCategoryRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(loanCategory);
            loanCategory.CategoryName = "New name";

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(loanCategory);

            // assert
            Assert.NotNull(result);
            Assert.Equal("New name", result.CategoryName);
        }

        [Fact]
        public async void Update_Location_Type_OK()
        {
            var locationType = new LocationType();
            _mockLocationTypeRepository.Setup(x => x.FindByIdAsync(It.IsAny<int>())).ReturnsAsync(locationType);
            locationType.Description = "New description";

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(locationType);

            // assert
            Assert.NotNull(result);
            Assert.Equal("New description", result.Description);
        }

        [Fact]
        public async void Update_Vehicle_Type_OK()
        {
            var vehicleType = new VehicleType();
            _mockVehicleTypeRepository.Setup(x => x.FindByIdAsync(It.IsAny<string>())).ReturnsAsync(vehicleType);
            vehicleType.Description = "New description";

            // arrange
            var service = BuildTestSettingsService();

            // act
            var result = await service.UpdateAsync(vehicleType);

            // assert
            Assert.NotNull(result);
            Assert.Equal("New description", result.Description);
        }
    }
}