using YLErp.Configuration;
using YLErp.DBModels;
using YLErp.DBModels.Consts;
using YLErp.DBModels.Enums;
using YLErp.Modules.TradeModule.DocGenerateModule;

namespace YLErp.UnitTestProject.Modules.TradeModule.DocGenerateModule
{
    [TestClass]
    public class GuolianSwapConfirmBookScopeTest
    {
        [TestMethod]
        public void IsPreApprovalTrade_AllAllowedStatuses_ReturnsTrue()
        {
            var statuses = new[]
            {
                ConsTrade.新增待确认,
                ConsTrade.修改待确认,
                ConsTrade.审批中
            };

            foreach (var status in statuses)
            {
                var trade = CreateTrade(status);

                Assert.IsTrue(GuolianSwapConfirmBookScope.IsPreApprovalTrade(trade, CompanyEnum.国联), status);
            }
        }

        [TestMethod]
        public void IsPreApprovalTrade_NonGuolianSwapOrInvalidTrade_ReturnsFalse()
        {
            var confirmedSwap = CreateTrade(ConsTrade.确认成交);
            var optionTrade = CreateTrade(ConsTrade.审批中, "香草期权");
            var invalidSwap = CreateTrade(ConsTrade.审批中);
            invalidSwap.ValidState = ConsGlobal.InValid;

            Assert.IsFalse(GuolianSwapConfirmBookScope.IsPreApprovalTrade(confirmedSwap, CompanyEnum.国联));
            Assert.IsFalse(GuolianSwapConfirmBookScope.IsPreApprovalTrade(optionTrade, CompanyEnum.国联));
            Assert.IsFalse(GuolianSwapConfirmBookScope.IsPreApprovalTrade(CreateTrade(ConsTrade.审批中), CompanyEnum.国泰君安));
            Assert.IsFalse(GuolianSwapConfirmBookScope.IsPreApprovalTrade(invalidSwap, CompanyEnum.国联));
        }

        [TestMethod]
        public void OtherActiveReferencePredicate_OnlyMatchesOtherActiveTrade()
        {
            const string contractCode = "GLMS-TEST-20260728-FICC-04-000001";
            var predicate = GuolianSwapConfirmBookCleanupService
                .BuildOtherActiveReferencePredicate(contractCode, 4)
                .Compile();

            Assert.IsFalse(predicate(CreateRelation(4, contractCode, ContractTypeEnum.Trade, true)));
            Assert.IsTrue(predicate(CreateRelation(7, contractCode, ContractTypeEnum.Trade, true)));
            Assert.IsFalse(predicate(CreateRelation(7, contractCode, ContractTypeEnum.Trade, false)));
            Assert.IsFalse(predicate(CreateRelation(7, "OTHER", ContractTypeEnum.Trade, true)));
            Assert.IsFalse(predicate(CreateRelation(7, contractCode, ContractTypeEnum.Clearing, true)));
        }

        [TestMethod]
        public void TradeConfirmationRelationPredicate_MatchesActiveAndInactiveRelations()
        {
            const string contractCode = "GLMS-TEST-20260728-FICC-04-000001";
            var predicate = GuolianSwapConfirmBookCleanupService
                .BuildTradeConfirmationRelationPredicate(4)
                .Compile();

            Assert.IsTrue(predicate(CreateRelation(4, contractCode, ContractTypeEnum.Trade, true)));
            Assert.IsTrue(predicate(CreateRelation(4, contractCode, ContractTypeEnum.Trade, false)));
            Assert.IsFalse(predicate(CreateRelation(7, contractCode, ContractTypeEnum.Trade, true)));
            Assert.IsFalse(predicate(CreateRelation(4, contractCode, ContractTypeEnum.Clearing, true)));
        }

        [TestMethod]
        public void ActiveOaResultPredicate_OnlyMatchesRejectedTradeActiveResult()
        {
            var predicate = GuolianSwapConfirmBookCleanupService
                .BuildActiveOaResultPredicate(4)
                .Compile();

            Assert.IsTrue(predicate(new trade_contract_oa_result { trade_id = 4, is_valid = true }));
            Assert.IsFalse(predicate(new trade_contract_oa_result { trade_id = 4, is_valid = false }));
            Assert.IsFalse(predicate(new trade_contract_oa_result { trade_id = 7, is_valid = true }));
        }

        private static trade CreateTrade(string status, string tradeType = "收益互换")
        {
            return new trade
            {
                TradeType = tradeType,
                TradeStatus = status,
                ValidState = ConsGlobal.Valid
            };
        }

        private static trade_contract_r CreateRelation(int tradeId, string contractCode, string type, bool isValid)
        {
            return new trade_contract_r
            {
                TradeId = tradeId,
                ContractCode = contractCode,
                Type = type,
                IsValid = isValid
            };
        }
    }
}