using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using YLErp.DBModels;

namespace YLErp.Modules.SwapModule
{
    public class SwapEventService : SwapTradeBaseService
    {
        public SwapEventService(OptUserInfo optUser) : base(optUser)
        {

        }
        public SwapEventService(YLBaseService baseService) : base(baseService)
        {

        }

        /// <summary>
        /// 生成事件
        /// </summary>
        /// <param name="tradeDate">日期</param>
        /// <param name="tradeId">互换交易码</param>
        /// <param name="eventType">事件类型</param>
        /// <param name="data">json数据</param>
        /// <param name="save">是否保存</param>
        /// <param name="clientCashId"></param>
        /// <param name="eventRession"></param>
        /// <param name="invalid">是否无效</param>
        /// <returns></returns>
        public swap_event AddSwapEventDate(DateTime tradeDate, int tradeId, int eventType, string data, int clientCashId, bool save = false,string eventRession="",bool invalid=false)
        {
            var swap_Event = new swap_event()
            {
                EventType = eventType,
                EventData = data,
                EventReason= eventRession,
                SwapTradeId = tradeId,
                ClientCashId = clientCashId,
                Invalid = invalid,
                ValueDate = tradeDate,
            };
            UpdateDbOption(swap_Event);
            DbContext.swap_event.Add(swap_Event);
            if (save)
            {
                DbContext.SaveChanges();
            }
            return swap_Event;
        }
        public swap_event UpdateSwapEvent()
        {
           var swapEvent= DbContext.swap_event.Where(x=>x.EventType== (int)SwapEventTypeEnum.新增交易 || x.EventType == (int)SwapEventTypeEnum.修改交易).OrderByDescending(o=>o.id).FirstOrDefault();
            if (swapEvent!=null)
            {
                swapEvent.Invalid= false;
                DbContext.SaveChanges();
            }
            return swapEvent;
        }
        /// <summary>
        /// 获取上一日终归档日期
        /// </summary>
        /// <param name="tradeDate">当前清算日期</param>
        /// <returns></returns>
        public DateTime GetSwapEventDate(DateTime tradeDate, int tradeId, int? eventType)
        {
            Expression<Func<swap_event, bool>> expression = x => x.SwapTradeId == tradeId && x.ValueDate < tradeDate && !x.Invalid;
            if (eventType.HasValue)
            {
                expression = expression.And(x => x.EventType == eventType);
            }
            var swapEvent = DbContext.swap_event.Where(expression).OrderByDescending(o => o.ValueDate).FirstOrDefault();
            if (swapEvent != null)
            {
                return swapEvent.ValueDate;//上一日终归档日期
            }
            else//不存在归档日期
            {
                return tradeDate;
            }
        }
        /// <summary>
        /// 保存展期信息
        /// </summary>
        /// <param name="swap_Event"></param>
        /// <returns></returns>
        /// <exception cref="ServiceException"></exception>
        public swap_event SaveExtensionTime(swap_event swap_Event)
        {
            var obj = DbContext.swap_event.Where(O => O.id == swap_Event.id).FirstOrDefault();
            var trade = DbContext.trade.Where(O => O.id == swap_Event.SwapTradeId).FirstOrDefault();
            if (trade == null)
            {
                throw new ServiceException("未找到交易,请刷新页面后再次尝试!");
            }
            var oldMaturityDate = trade.ExerciseDate.Value;
            if (obj != null && !string.IsNullOrEmpty(obj.EventData))
            {
                oldMaturityDate = JsonConvert.DeserializeObject<ExtenstionData>(obj.EventData).OldMaturityDate;
            }
            if (swap_Event.extenstionData.NewMaturityDate <= oldMaturityDate)
            {
                throw new ServiceException("新到期日应晚于原到期日!");
            }
            if (obj != null && obj.ValueDate >= swap_Event.ValueDate)
            {
                throw new ServiceException("新展期日应晚于原展期日!");
            }
            if (swap_Event.extenstionData.NewMaturityDate< trade.StartDate)
            {
                throw new ServiceException("新到期日不应早于交易开始日期!");
            }
            swap_Event.extenstionData.OldMaturityDate = oldMaturityDate;
            string data = JsonConvert.SerializeObject(swap_Event.extenstionData);
            if (obj != null)
            {
                obj.Invalid = true;
            }
            swap_Event.EventReason = "交易展期";
            trade.ExerciseDate = swap_Event.extenstionData.NewMaturityDate;
            //修改互换观察日到期日
            new SwapTradeService(this).UpdateObservationDay(trade.id, swap_Event.extenstionData.OldMaturityDate, trade.ExerciseDate.Value);
            swap_Event = AddSwapEventDate(swap_Event.ValueDate, swap_Event.SwapTradeId, (int)SwapEventTypeEnum.展期, data, 0,false, swap_Event.EventReason);
            DbContext.SaveChanges();
            return swap_Event;
        }
        /// <summary>
        /// 删除 展期
        /// </summary>
        /// <param name="id"></param>
        /// <exception cref="ServiceException"></exception>
        public void DeleteExtensionTime(long id)
        {
            var obj = DbContext.swap_event.Where(O => O.id == id).FirstOrDefault();
            if (obj==null)
            {
                throw new ServiceException("未找到展期记录,请刷新页面后再次尝试!");
            }
            var trade = DbContext.trade.Where(O => O.id == obj.SwapTradeId).FirstOrDefault();
            obj.Invalid = true;
            obj.EventReason = "交易展期撤销";
            if (!string.IsNullOrEmpty(obj.EventData))
            {
                obj.extenstionData = JsonConvert.DeserializeObject<ExtenstionData>(obj.EventData);
                //修改到期日，互换观察日
                new SwapTradeService(this).UpdateObservationDay(trade.id, trade.ExerciseDate.Value, obj.extenstionData.OldMaturityDate);
                trade.ExerciseDate = obj.extenstionData.OldMaturityDate;
            }
            DbContext.SaveChanges();
        }
        /// <summary>
        /// 获取当前展期记录
        /// </summary>
        /// <param name="tradeId"></param>
        /// <returns></returns>
        public swap_event GetExtensionTime(int tradeId)
        {
            var trade = DbContext.trade.Where(O => O.id == tradeId).FirstOrDefault();
            if (trade == null)
            {
                throw new ServiceException("未找到交易,请刷新页面后再次尝试!");
            }
            var extension = DbContext.swap_event.Where(x => !x.Invalid && x.SwapTradeId == tradeId && x.EventType == (int)SwapEventTypeEnum.展期).FirstOrDefault();
           
            if (extension==null)
            {
                extension = new swap_event();
                extension.SwapTradeId = tradeId;
                extension.ValueDate = DateTime.Now;
                extension.extenstionData = new ExtenstionData()
                {
                    OldMaturityDate = trade.ExerciseDate.Value,
                    NewMaturityDate=DateTime.Now
                };
            }
            else
            {
                if (!string.IsNullOrEmpty(extension.EventData))
                {
                    extension.extenstionData = JsonConvert.DeserializeObject<ExtenstionData>(extension.EventData);
                }
            }
            extension.SwapTradeNumber = trade.TradeNumber;
            return extension;
        }
        /// <summary>
        /// 获取历史展期信息
        /// </summary>
        /// <param name="tradeId"></param>
        /// <returns></returns>
        public List<swap_event> GetExtenstionTimeEvents(int tradeId)
        {
           var events= DbContext.swap_event.Where(x => x.Invalid && x.SwapTradeId == tradeId&&x.EventType==(int)SwapEventTypeEnum.展期).OrderByDescending(o => o.ValueDate).ToList();
            events.ForEach(x =>
            {
                if (!string.IsNullOrEmpty(x.EventData))
                {
                    x.extenstionData = JsonConvert.DeserializeObject<ExtenstionData>(x.EventData);
                }
            });
            return events;
        }
        /// <summary>
        /// 获取交易操作历史。登记日创建的待生效公司行为仍保留在审计数据中，
        /// 但在 EffectiveDate 将其更新为 Applied=true 前不对操作历史展示。
        /// </summary>
        /// <param name="tradeId">交易id</param>
        /// <returns></returns>
        public List<swap_event> GetOpreationHistorys(int tradeId)
        {
            List<swap_event> list = DbContext.swap_event
                .Where(x => x.SwapTradeId == tradeId)
                .OrderByDescending(o => o.id)
                .ToList();
            return FilterOperationHistory(list);
        }

        /// <summary>
        /// 过滤尚未生效的公司行为事件。非公司行为、已生效事件和无法识别的历史事件均保留，
        /// 避免过滤条件误伤既有操作记录。
        /// </summary>
        private static List<swap_event> FilterOperationHistory(IEnumerable<swap_event> events)
        {
            if (events == null)
            {
                return new List<swap_event>();
            }

            return events
                .Where(x => !IsPendingCorporateActionEvent(x))
                .ToList();
        }

        private static bool IsPendingCorporateActionEvent(swap_event swapEvent)
        {
            return swapEvent?.EventType == (int)SwapEventTypeEnum.公司行为
                && TryDeserializeCorporateActionEventData(swapEvent, out var data)
                && !data.Applied;
        }

        /// <summary>
        /// 将 swap_event.EventData 安全反序列化为公司行为快照。事件为空、EventData
        /// 为空白或 JSON 格式不匹配时返回 false 并将 data 置 null，调用方据此保留旧格式记录。
        /// </summary>
        public static bool TryDeserializeCorporateActionEventData(
            swap_event swapEvent,
            out CorporateActionEventData data)
        {
            data = null;
            if (swapEvent == null || string.IsNullOrWhiteSpace(swapEvent.EventData))
            {
                return false;
            }

            try
            {
                data = JsonConvert.DeserializeObject<CorporateActionEventData>(swapEvent.EventData);
                return data != null;
            }
            catch (JsonException)
            {
                return false;
            }
        }

        /// <summary>
        /// 公司行为说明仅展示调整前后的名义本金、期初标的价格和持仓数量，
        /// 便于操作历史直接比对持仓基线。
        /// </summary>
        public static string BuildCorporateActionEventReason(CorporateActionEventData data)
        {
            if (data == null)
            {
                return "公司行为快照为空";
            }

            // 使用 InvariantCulture 固定小数和日期格式，说明文本不随服务器区域设置变化。
            string D(decimal value) => value.ToString(CultureInfo.InvariantCulture);
            string Date(DateTime? value) => value.HasValue
                ? value.Value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture)
                : "";
            string ActionDescription()
            {
                if (data.RationedSharesAmount != 0m)
                {
                    return "配股";
                }
                if (data.GiveShareAmount != 0m)
                {
                    return "送股";
                }
                if (data.Split.HasValue && data.Split.Value != 1m)
                {
                    return "拆分";
                }
                if (data.GiveCashAmount != 0m)
                {
                    // return $"产生分红：{D(data.CashFlowChange)}";
                    return $"产生分红";
                }
                return "公司行为";
            }

            return $"股权登记日：{Date(data.ExDividendDate)} 发生公司行为（{ActionDescription()}）"
                + Environment.NewLine
                + $"调整前：名义本金：{D(data.BeforeNotional)}  期初标的价格：{D(data.BeforePrice)} 持仓数量：{D(data.BeforeQuantity)}"
                + Environment.NewLine
                + $"调整后：名义本金：{D(data.AfterNotional)}  期初标的价格：{D(data.AfterPrice)} 持仓数量：{D(data.AfterQuantity)}";
        }

        public void DeleteEvent(int tradeId)
        {
            var events = DbContext.swap_event.Where(x => x.Invalid && x.SwapTradeId == tradeId).ToList();
            var flowEvents= DbContext.swap_flow_event.Where(x => x.DataState>0 && x.SwapTradeId == tradeId).ToList();
            events.ForEach((x) =>
            {
                x.Invalid = true;
            });
            flowEvents.ForEach((x) =>
            {
                x.DataState = (int)SwapFlowDateStateEnum.废弃;
            });
            DbContext.SaveChanges();
        }
    }
}