using BitgetApi.Data;
using BitgetAPI.IndicatorConditionSetup;
using DevExpress.Utils.IoC;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using static BitgetAPI.CommonProperty;

namespace BitgetAPI.IndicatorConditionSetup
{
    public class IndicatorProcess
    {
        CommonProperty commonProperty = CommonProperty.Instance;

        // 스레드 시작/종료 플래그
        public bool Is_th_SignalInfo;

        public List<object> checkedMarkets;
        public List<object> intervalList;

        // 신호검색 리스트 작성 
        // 신호 Long 상승 (구매)
        public List<SignalInfoData> signals_LU = null;
        // 신호 Short 하락 (구매)
        public List<SignalInfoData> signals_SD = null;
        // 검색현황 Long 하락 (판매)
        public List<SignalInfoData> signals_LD = null;
        // 검색현황 Short 상승 (판매)
        public List<SignalInfoData> signals_SU = null;

        public TimeSpan sesstionTime;

        // 조건식 설정 상태
        public bool checked구름떼상향돌파 = false;
        public bool checked구름떼하향돌파 = false;
        public bool 영호조건식_상향돌파 = false;
        public bool 영호조건식_하향돌파 = false;

        //구매 리스트
        public Dictionary<string, Dictionary<string, object>> BuyList = new Dictionary<string, Dictionary<string, object>>();
        //결과 리스트
        public List<Dictionary<string, object>> ResultList = new List<Dictionary<string, object>>();


        // 전봉이 구름떼 돌파후 시가가 구름떼 위에서 시작하는 것
        // 전봉이 구름떼 하락후 시가가 구름떼 밑에서 시작하는 것

        public void calProcess()
        {
            IchimokuConditionSetup ichimokuConditionSetup = new IchimokuConditionSetup();
            MovingAverageConditionSetup movingAverageConditionSetup = new MovingAverageConditionSetup();

            signals_LU.Clear();
            signals_SD.Clear();
            signals_LD.Clear();
            signals_SU.Clear();

            // 추후 공통화 및 소스정리 필요
            while (true)
            {
                if (!Is_th_SignalInfo) break;
                //Thread.Sleep(200);
                var nowTime = DateTime.Now;

                // 특정 시간 이후 삭제
                foreach (var item in signals_LU.ToList())
                {
                    // 시간 지나면 삭제
                    if (item.SignalStart + sesstionTime < nowTime)
                    {
                        signals_LU.Remove(item);
                        continue;

                    }

                    var findedMarket = commonProperty.candleDataLists.Find(i => i.ConGoodsData.MarketName == item.MarketName);
                    var lastCandleData = findedMarket.candleDataList[item.MCandleTimeType].OrderBy(i => i.Argument).ToList().Last();

                    if (lastCandleData.IchimokData != null)
                    {
                        if (checked구름떼상향돌파 || 영호조건식_상향돌파)
                        {
                            item.Price = lastCandleData.Close;
                            item.Rate = (lastCandleData.Close / lastCandleData.Open) * 100 - 100;
                            item.IndicatorRate = (lastCandleData.Close / item.IndicatorPrice) * 100 - 100;
                        }
                    }
                }
                foreach (var item in signals_SD.ToList())
                {
                    // 시간 지나면 삭제
                    if (item.SignalStart + sesstionTime < nowTime)
                    {
                        signals_SD.Remove(item);
                        continue;

                    }

                    var findedMarket = commonProperty.candleDataLists.Find(i => i.ConGoodsData.MarketName == item.MarketName);
                    var lastCandleData = findedMarket.candleDataList[item.MCandleTimeType].OrderBy(i => i.Argument).ToList().Last();

                    if (lastCandleData.IchimokData != null)
                    {
                        if (checked구름떼하향돌파 || 영호조건식_하향돌파)
                        {
                            item.Price = lastCandleData.Close;
                            item.Rate = (lastCandleData.Close / lastCandleData.Open) * 100 - 100;
                            item.IndicatorRate = (lastCandleData.Close / item.IndicatorPrice) * 100 - 100;
                        }
                    }
                }
                foreach (var item in signals_LD.ToList())
                    if (item.SignalStart + sesstionTime < nowTime) signals_SU.Remove(item);
                foreach (var item in signals_SU.ToList())
                    if (item.SignalStart + sesstionTime < nowTime) signals_SD.Remove(item);

                // 체크된 마켓 정보
                foreach (string market in checkedMarkets)
                {
                    var findedMarket = commonProperty.candleDataLists.Find(i => i.ConGoodsData.MarketName == market);

                    foreach (CommonProperty.MCandleTimeType interval in Enum.GetValues(typeof(CommonProperty.MCandleTimeType)))
                    {
                        // Description
                        var strInterval = Utils.Convertor.GetEnumDescription((Enum)interval);
                        if (!intervalList.Contains(strInterval)) continue;

                        // 시간별로 정렬하기 (임시 리스트)
                        var candleDatas = findedMarket.candleDataList[interval];
                        var candleDatas_정렬 = candleDatas.OrderBy(i => i.Argument).ToList();

                        var candleData = candleDatas.Find(i => i.Argument == candleDatas_정렬.Last().Argument);

                        if (candleData == null) continue;

                        ichimokuConditionSetup.calIchimokuData(candleDatas_정렬, candleData);
                        movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_정렬, candleData);

                        candleDatas_정렬.RemoveAt(candleDatas_정렬.Count - 1);
                        var candleData_전봉 = candleDatas.Find(i => i.Argument == candleDatas_정렬.Last().Argument);

                        ichimokuConditionSetup.calIchimokuData(candleDatas_정렬, candleData_전봉);
                        movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_정렬, candleData_전봉);


                        if (checked구름떼상향돌파 && candleData_전봉.Open < candleData_전봉.IchimokData.상한선 && candleData.Open > candleData.IchimokData.상한선 && candleData.Low > candleData.IchimokData.상한선
                            && candleData.Close > candleData.IchimokData.상한선)
                        {

                            var price = candleData.Close;
                            var rate = (candleData.Close / candleData.Open) * 100 - 100;
                            var indicatorPrice = candleData.Open;
                            var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;

                            var description = string.Format("{0} 구름떼 상승", strInterval);
                            var signalData = signals_LU.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));

                            // 없으면 생성
                            if (signalData == null)
                            {
                                SignalInfoData signalInfoData = new SignalInfoData();
                                signalInfoData.SignalStart = nowTime;
                                signalInfoData.MarketName = market;
                                signalInfoData.Description = description;
                                signalInfoData.Rate = rate;
                                signalInfoData.Price = price;
                                signalInfoData.IndicatorPrice = indicatorPrice;
                                signalInfoData.IndicatorRate = indicatorRate;
                                signalInfoData.MCandleTimeType = interval;

                                signals_LU.Add(signalInfoData);
                            }

                        }
                        else if (checked구름떼상향돌파 && candleData_전봉.Open > candleData_전봉.IchimokData.하한선 && candleData.Open < candleData.IchimokData.하한선 && candleData.High < candleData.IchimokData.하한선
                            && candleData.Close < candleData.IchimokData.하한선)
                        {
                            var price = candleData.Close;
                            var rate = (candleData.Close / candleData.Open) * 100 - 100;
                            var indicatorPrice = candleData.Open;
                            var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;

                            var description = string.Format("{0} 구름떼 하락", strInterval);
                            var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));

                            // 없으면 생성
                            if (signalData == null)
                            {
                                SignalInfoData signalInfoData = new SignalInfoData();
                                signalInfoData.SignalStart = nowTime;
                                signalInfoData.MarketName = market;
                                signalInfoData.Description = description;
                                signalInfoData.Rate = rate;
                                signalInfoData.Price = price;
                                signalInfoData.IndicatorPrice = indicatorPrice;
                                signalInfoData.IndicatorRate = indicatorRate;
                                signalInfoData.MCandleTimeType = interval;

                                signals_SD.Add(signalInfoData);
                            }
                        }

                        if (영호조건식_상향돌파 || 영호조건식_하향돌파)
                        {
                            candleDatas_정렬.RemoveAt(candleDatas_정렬.Count - 1);
                            var candleData_전전봉 = candleDatas.Find(i => i.Argument == candleDatas_정렬.Last().Argument);

                            movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas_정렬, candleData_전전봉);

                            // 24,72 높은값
                            var 높은값_74_24_전전봉 = Math.Max(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
                            // 24,72 낮은값
                            var 낮은값_74_24_전전봉 = Math.Min(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);

                            // 24,72 높은값
                            var 높은값_74_24_전봉 = Math.Max(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);
                            // 24,72 낮은값
                            var 낮은값_74_24_전봉 = Math.Min(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);

                            // 24,72 높은값
                            var 높은값_74_24 = Math.Max(candleData.movingAverageDataList[72].Value, candleData.movingAverageDataList[24].Value);
                            // 24,72 낮은값
                            var 낮은값_74_24 = Math.Min(candleData.movingAverageDataList[72].Value, candleData.movingAverageDataList[24].Value);

                            var 전봉24 = candleData_전봉.movingAverageDataList[24].Value;
                            var 전봉72 = candleData_전봉.movingAverageDataList[72].Value;
                            var 현재봉4 = candleData.movingAverageDataList[4].Value;
                            var 현재봉24 = candleData.movingAverageDataList[24].Value;
                            var 현재봉72 = candleData.movingAverageDataList[72].Value;

                            var 전봉Bol12 = candleData_전봉.movingAverageDataList[12].BolangerValue;
                            var 전봉Bol24 = candleData_전봉.movingAverageDataList[24].BolangerValue;

                            var 전전봉Bol12 = candleData_전전봉.movingAverageDataList[12].BolangerValue;
                            var 전전봉Bol24 = candleData_전전봉.movingAverageDataList[24].BolangerValue;
                            var Bol12 = candleData.movingAverageDataList[12].BolangerValue;
                            var Bol24 = candleData.movingAverageDataList[24].BolangerValue;

                            ////볼랜저 12 24중 12가 크고 전전봉 전봉 12 차이보다 전전봉 전봉 24가 작아야함(하향)
                            //var data12 = 전봉Bol12 - 전전봉Bol12 > 0
                            //        ? 전봉Bol12 - 전전봉Bol12 :
                            //        (전봉Bol12 - 전전봉Bol12) * -1;


                            //var data24 = 전봉Bol24 - 전전봉Bol24 > 0
                            //        ? 전봉Bol24 - 전전봉Bol24 :
                            //        (전봉Bol24 - 전전봉Bol24) * -1;

                            //var buyFlag = 전봉Bol12 - 전봉Bol24 > Bol12 - Bol24 && 전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24;


                            //var sellFlag = 전봉Bol12 - 전봉Bol24 < Bol12 - Bol24 || 현재봉4 > 낮은값_74_24;

                            var buyFlag = candleData_전봉.movingAverageDataList[12].BolangerValue > candleData_전봉.movingAverageDataList[24].BolangerValue && 전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24;

                            //파는 시점 볼랜저 전전봉 12 - 24 값이 전봉 12 - 24보다 클경우 팜
                            var sellFlag = 전전봉Bol12 - 전전봉Bol24 < 전봉Bol12 - 전봉Bol24 || 현재봉4 > 낮은값_74_24;

                            //파는 시점 볼랜저 전전봉 12 - 24 값이 전봉 12 - 24보다 클경우 팜
                            //var buyFlag = candleData_전봉.movingAverageDataList[12].BolangerValue > candleData_전봉.movingAverageDataList[24].BolangerValue && 전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24;

                            ////파는 시점 볼랜저 전전봉 12 - 24 값이 전봉 12 - 24보다 클경우 팜
                            //var sellFlag = 전전봉Bol12 - 전전봉Bol24 < 전봉Bol12 - 전봉Bol24 || 현재봉4 > 낮은값_74_24;


                            if (영호조건식_상향돌파 &&

                                // 전전봉의 4가 74, 21 보다 높고
                                candleData_전전봉.movingAverageDataList[4].Value <= 높은값_74_24_전전봉 &&
                                // 전봉의 4가 74,21 보다 작고나서
                                candleData_전봉.movingAverageDataList[4].Value > 높은값_74_24_전봉 &&
                                // 현재 시가도 4가 74,21 보다 작고, 고가도 
                                candleData.movingAverageDataList[4].Value > 높은값_74_24)
                            {
                                var price = candleData.Close;
                                var rate = (candleData.Close / candleData.Open) * 100 - 100;
                                var indicatorPrice = candleData.Open;
                                var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;

                                var description = string.Format("{0} 72,24,4 상승", strInterval); ;
                                var signalData = signals_LU.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));

                                // 없으면 생성
                                if (signalData == null)
                                {
                                    SignalInfoData signalInfoData = new SignalInfoData();
                                    signalInfoData.SignalStart = nowTime;
                                    signalInfoData.MarketName = market;
                                    signalInfoData.Description = description;
                                    signalInfoData.Rate = rate;
                                    signalInfoData.Price = price;
                                    signalInfoData.IndicatorPrice = indicatorPrice;
                                    signalInfoData.IndicatorRate = indicatorRate;
                                    signalInfoData.MCandleTimeType = interval;

                                    signals_LU.Add(signalInfoData);
                                }
                            }
                            else if (영호조건식_하향돌파)
                            {
                                var price = candleData.Close;
                                var rate = (candleData.Close / candleData.Open) * 100 - 100;
                                var indicatorPrice = candleData.Open;
                                var indicatorRate = (candleData.Close / indicatorPrice) * 100 - 100;

                                var description = string.Format("{0} 72,24,4 하락", strInterval);
                                var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));

                                // 없으면 생성
                                if (signalData == null)
                                {
                                    SignalInfoData signalInfoData = new SignalInfoData();
                                    signalInfoData.SignalStart = nowTime;
                                    signalInfoData.MarketName = market;
                                    signalInfoData.Description = description;
                                    signalInfoData.Rate = rate;
                                    signalInfoData.Price = price;
                                    signalInfoData.IndicatorPrice = indicatorPrice;
                                    signalInfoData.IndicatorRate = indicatorRate;
                                    signalInfoData.MCandleTimeType = interval;

                                    signals_SD.Add(signalInfoData);
                                }
                                try
                                {
                                    //사는 시점
                                    if (!BuyList.ContainsKey(market + interval))
                                    {
                                        if ((candleData_전전봉.movingAverageDataList[4].Value > 낮은값_74_24_전전봉
                                            && candleData_전전봉.movingAverageDataList[4].Value < 높은값_74_24_전전봉) &&
                                            // 현재의 4가 74,21 보다 작고나서
                                            (candleData_전봉.movingAverageDataList[4].Value < 낮은값_74_24_전봉 &&
                                            낮은값_74_24_전봉 < candleData.IchimokData.상한선) &&
                                            //볼랜저 12 24중 12가 크고 전전봉 전봉 12 차이보다 전전봉 전봉 24가 작아야함(하향)
                                            buyFlag)
                                        {
                                            var buyDic = new Dictionary<string, object>
                                            {
                                                { "MarketName", market },
                                                { "BuyDate", nowTime },
                                                { "Price", price },
                                                { "MCandleTimeType", (int)interval },
                                                { "Candle", candleData }
                                            };

                                            BuyList.Add(market + interval, buyDic);
                                        }
                                    }
                                    //파는 시점
                                    else
                                    {
                                        var buyItem = BuyList[market + interval];
                                        if (interval < MCandleTimeType.H1)
                                        {
                                            if (nowTime < ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval))
                                            {
                                                continue;
                                            }
                                        }
                                        //임시로 처리
                                        else
                                        {
                                            if (nowTime < ((DateTime)buyItem["BuyDate"]).AddHours((int)interval))
                                            {
                                                continue;
                                            }
                                        }
                                        if (sellFlag)
                                        {

                                            double.TryParse(buyItem["Price"].ToString(), out var buyPrice);
                                            var resultRate = ((price - buyPrice) / buyPrice) * 100;

                                            var result = new Dictionary<string, object>()
                                        {
                                            { "MarketName", market },
                                            { "BuyDate", buyItem["BuyDate"]},
                                            { "BuyPrice", buyPrice },
                                            { "MCandleTimeType", (int)interval },
                                            { "BuyCandle",  buyItem["Candle"] },
                                            { "SellDate", nowTime},
                                            { "SellPrice", price },
                                            { "SellCandle",  candleData },
                                            { "Rate", resultRate }
                                        };

                                            ResultList.Add(result);
                                            BuyList.Remove(market + interval);
                                        }
                                    }
                                }
                                catch (Exception e)
                                {

                                }
                            }
                        }
                    }
                }

            }
        }

        public void calIchimokuProcess_Add()
        {


        }

        public void calIchimokuProcess_Update()
        {

        }
    }
}