using System.Reflection;
using YLErp.DBModels;

namespace YLErp.Modules.SwapModule
{
    [TestClass]
    public class InitUnwindTradingFeeTest
    {
        private static decimal InvokeCalcInitTradingFee(swap_position position, UnwindData unwindData)
        {
            var method = typeof(SwapDealService).GetMethod(
                "CalcInitTradingFee",
                BindingFlags.NonPublic | BindingFlags.Static);

            Assert.IsNotNull(method, "未找到 CalcInitTradingFee 私有静态方法");

            return (decimal)method.Invoke(null, new object[] { position, unwindData });
        }

        private static decimal InvokeCalcInitTradingFeePending(swap_position oriPosition, swap_position position, UnwindData unwindData)
        {
            var method = typeof(SwapDealService).GetMethod(
                "CalcInitTradingFeePending",
                BindingFlags.NonPublic | BindingFlags.Static);

            Assert.IsNotNull(method, "CalcInitTradingFeePending was not found");

            return (decimal)method.Invoke(null, new object[] { oriPosition, position, unwindData });
        }

        [TestMethod]
        public void 百分比模式_按平仓名义本金计算并四舍五入到两位()
        {
            var position = new swap_position
            {
                PosiFeeType = 0,
                PosiTradingFeeUnit = 0.1234m,
                PosiTradingFeePending = 1234.00m
            };
            var unwindData = new UnwindData
            {
                NotionalValue = 1_000_000m,
                CloseNotionalValue = 1_000_000m,
                CloseQty = 8888m
            };

            var fee = InvokeCalcInitTradingFee(position, unwindData);

            Assert.AreEqual(1234.00m, fee);
        }

        [TestMethod]
        public void 单位数量模式_按平仓数量计算并四舍五入到两位()
        {
            var position = new swap_position
            {
                PosiFeeType = 1,
                PosiTradingFeeUnit = 1.235m,
                PosiTradingFeePending = 12.35m
            };
            var unwindData = new UnwindData
            {
                NotionalQty = 10m,
                CloseNotionalValue = 1_000_000m,
                CloseQty = 10m
            };

            var fee = InvokeCalcInitTradingFee(position, unwindData);

            Assert.AreEqual(12.35m, fee);
        }

        [TestMethod]
        public void 空入参_返回零()
        {
            Assert.AreEqual(0m, InvokeCalcInitTradingFee(null, new UnwindData()));
            Assert.AreEqual(0m, InvokeCalcInitTradingFee(new swap_position(), null));
        }

        [TestMethod]
        public void BaseRatePendingFeeUsesTheSameActualCloseAmountAsCloseFee()
        {
            var oriPosition = new swap_position
            {
                PosiFeeType = 1,
                PosiTradingFeeUnit = 0.2m
            };
            oriPosition.PosiTradingFeePending = 2000m;
            var position = new swap_position { PosiTradingFeePending = 840m };
            var unwindData = new UnwindData { NotionalQty = 10000m, CloseQty = 3000m, CloseNotionalValue = 4200m };

            var fee = InvokeCalcInitTradingFeePending(oriPosition, position, unwindData);

            Assert.AreEqual(600m, fee);
        }

        [TestMethod]
        public void BaseRatePendingFeeAllocatesManuallyAdjustedOriginalPendingFee()
        {
            var oriPosition = new swap_position
            {
                PosiFeeType = 1,
                PosiTradingFeeUnit = 0.2m,
                PosiTradingFeePending = 1500m
            };
            var unwindData = new UnwindData { NotionalQty = 10000m, CloseQty = 3000m };

            var fee = InvokeCalcInitTradingFeePending(oriPosition, new swap_position(), unwindData);

            Assert.AreEqual(450m, fee);
        }

        [TestMethod]
        public void ManuallyAdjustedPendingFeeDoesNotOverrideBaseRateCloseFee()
        {
            var oriPosition = new swap_position
            {
                PosiFeeType = 1,
                PosiTradingFeeUnit = 0.123456m,
                PosiTradingFeePending = 1235.56m
            };
            var unwindData = new UnwindData
            {
                NotionalQty = 10000m,
                CloseQty = 10000m
            };

            var tradingFee = InvokeCalcInitTradingFee(oriPosition, unwindData);
            var pendingFee = InvokeCalcInitTradingFeePending(oriPosition, new swap_position(), unwindData);

            Assert.AreEqual(1234.56m, tradingFee);
            Assert.AreEqual(1235.56m, pendingFee);
        }

        [TestMethod]
        public void LegacyPendingFeeKeepsCurrentPositionValueWhenNoBaseRateIsConfigured()
        {
            var oriPosition = new swap_position { PosiTradingFeeUnit = 0m };
            var position = new swap_position { PosiTradingFeePending = 840m };

            var fee = InvokeCalcInitTradingFeePending(oriPosition, position, new UnwindData());

            Assert.AreEqual(840m, fee);
        }
    }
}