using BitgetAPI.Data;
using BitgetAPI.Data.IndicatorData;
using DevExpress.Utils.Extensions;
using DevExpress.XtraBars.Ribbon.Gallery;
using DevExpress.XtraBars.ViewInfo;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Media.Media3D;
using static BitgetAPI.CommonProperty;
using static DevExpress.Utils.Diagnostics.GUIResources;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.ToolTip;

namespace BitgetApi.IndicatorConditionSetup
{
    public class IchimokuResult
    {
        public DateTime Time { get; set; }
        public double TenkanSen { get; set; }      // 전환선
        public double KijunSen { get; set; }       // 기준선
        public double SenkouSpanA { get; set; }    // 선행스팬1
        public double SenkouSpanB { get; set; }    // 선행스팬2
        public double ChikouSpan { get; set; }     // 후행스팬
    }


    public class SMABandConditionSetup
    {
        private readonly int rangeLookback = 12;
        private double rangeThresholdLongPercent = 2;
        private double rangeThresholdShortPercent = 2;
        /// <summary>
        ///     false 는 구매 전, true는 판매 후
        /// </summary>
        private bool firstCloudFlag = true;


        public bool Calculate(List<CandleData> candles, SMABandType type, string market, bool flag = false)
        {

            var close = candles.Select(t => t.Close).ToList();

            var high = candles.Select(t => t.High).ToList();

            var low = candles.Select(t => t.Low).ToList();

            var open = candles.Select(t => t.Open).ToList();

            if (flag)
            {
                close.RemoveAt(close.Count - 1);
                high.RemoveAt(high.Count - 1);
                low.RemoveAt(low.Count - 1);
                open.RemoveAt(open.Count - 1);
            }

            int i = close.Count - 1;
            if (close.Count < 100 || high.Count < 100 || low.Count < 100 || open.Count < 100)
                return false;

            var longAverage = 0.0;
            var shortAverage = 0.0;

            for (var j = 0; j < 120; j++)
            {
                longAverage += (candles[j].High - candles[j].Low) / candles[j].Close * 100;
                shortAverage += (candles[j].High - candles[j].Low) / candles[j].Close * 100;
            }

            rangeThresholdLongPercent = longAverage / 120 * 2;
            rangeThresholdShortPercent = shortAverage / 120 * 1.7;

            double sma72 = CalculateSMA(close, i);
            double prevSma72 = CalculateSMA(close, i - 1);

            // SMA4 관련
            double sma4 = CalculateSMA(close, i, 4);
            double prevSma4 = CalculateSMA(close, i - 1, 4);
            double prev2Sma4 = CalculateSMA(close, i - 2, 4);
            double prev3Sma4 = CalculateSMA(close, i - 3, 4);

            // 밴드 계산
            double sma4High = Highest(close, i, 12, 4);
            double sma4Middle = CalculateSMA(close, i, 12);
            double sma4Low = Lowest(close, i, 12, 4);

            double prevSma4High = Highest(close, i - 1, 12, 4);
            double prevSma4Middle = CalculateSMA(close, i - 1, 12);
            double prevSma4Low = Lowest(close, i - 1, 12, 4);

            double prev2Sma4High = Highest(close, i - 2, 12, 4);
            double prev2Sma4Low = Lowest(close, i - 2, 12, 4);
            double prev2Sma4Middle = CalculateSMA(close, i - 2, 12);

            double prev3Sma4High = Highest(close, i - 3, 12, 4);
            double prev3Sma4Low = Lowest(close, i - 3, 12, 4);
            double prev3Sma4Middle = CalculateSMA(close, i - 3, 12);


            var ichmok = GetIchimokuCloud(candles, i - 25);
            var ichmokCurrent = GetIchimokuCloud(candles, i);

            var cloudTopNow = Math.Max(ichmok.SenkouSpanA, ichmok.SenkouSpanB);
            var cloudBottomNow = Math.Min(ichmok.SenkouSpanA, ichmok.SenkouSpanB);

            bool isSma4BelowCloud = low[i] < cloudBottomNow;
            bool isSma4AboveCloud = high[i] > cloudTopNow;            

            bool greenCandle = open[i] < close[i];
            bool redCandle = open[i] > close[i];

            var isLongRecentTouch = true;
            var isShortRecentTouch = true;

            for (var cnt = 0; cnt < 10; cnt++)
            {                
                if (Lowest(close, i - cnt, 12, 4) == CalculateSMA(close, i - cnt, 12) && Lowest(close, i - cnt-1, 12, 4) <= CalculateSMA(close, i - cnt-1, 12))
                {
                    isLongRecentTouch = false;
                    break;
                }                
            }

            for (var cnt = 0; cnt < 5; cnt++)
            {
                if (Highest(close, i - cnt, 12, 4) == CalculateSMA(close, i - cnt, 12) && Highest(close, i - cnt - 1, 12, 4) >= CalculateSMA(close, i - cnt - 1, 12))
                {
                    isShortRecentTouch = false;
                    break;
                }
            }


            // 진입/청산 조건
            bool rawNewLong = isLongRecentTouch && greenCandle && IsSideways(high, low, i, true, rangeThresholdLongPercent) && prevSma4 <= sma4 && sma4High == sma4 && prevSma4High >= prevSma4 && (prev2Sma4Middle - prevSma4Middle) > (prevSma4Middle - sma4Middle) && sma4Middle > sma72 && sma4 > cloudTopNow;
            bool rawLongSell = (sma4Middle < sma72 && prevSma4Middle > prevSma72) || (sma4 == sma4Low);

            bool rawNewShort = sma4High < cloudBottomNow && sma4 == sma4Low && IsSideways(high, low, i, false, rangeThresholdShortPercent);
            bool rawShortSell = sma4 > cloudBottomNow;

            //bool rawNewLong = greenCandle && sma4Low < sma72 && IsSideways(high, low, i, true) && sma4 > cloudTopNow && prevSma4 <= prevSma4High && sma4 == sma4High && prevSma4 < sma4 && sma4Middle > sma72 && sma4 > cloudTopNow && ichmok.SenkouSpanA >= ichmok.SenkouSpanB && ichmokCurrent.SenkouSpanA >= ichmokCurrent.SenkouSpanB;
            //sma4 == sma4High && prevSma4 < sma4High && sma4Middle > sma72 && sma4 > cloudTopNow && ichmokCurrent.SenkouSpanA > ichmokCurrent.SenkouSpanB && ichmok.SenkouSpanA >= ichmok.SenkouSpanB; // sma4 > cloudBottomNow && IsSideways(high, low, i, true) && isSma4AboveCloud && (sma4 == sma4High && prevSma4 <= prevSma4High && prev2Sma4 <= prev2Sma4High) && (sma4 >= prevSma4 && prevSma4 >= prev2Sma4 && prev2Sma4 >= prev3Sma4);

            //bool rawLongSell = (sma4Middle < sma72 && prevSma4Middle > prevSma72) || (sma4 == sma4Low);
            //(sma4Middle < sma72 && prevSma4Middle > prevSma72) || (sma4 < cloudBottomNow);// (sma4 <= prevSma4 && prevSma4 <= prev2Sma4 && sma4 < sma4Middle);

            //cloudFlag &&
            //bool rawNewShort = sma4 == sma4Low && prevSma4 > sma4Low && sma4Middle < sma72 && sma4 < cloudBottomNow;// sma4High < sma72 && prevSma4High > prevSma72;//sma4 < cloudTopNow && IsSideways(high, low, i, false) && isSma4BelowCloud && (sma4 == sma4Low && prevSma4 >= prevSma4Low && prev2Sma4 >= prev2Sma4Low) && (sma4 <= prevSma4 && prevSma4 <= prev2Sma4 && prev2Sma4 <= prev3Sma4);

            //bool rawShortSell = (sma4Middle > sma72 && prevSma4Middle < prevSma72) || (sma4 > cloudTopNow);//(sma4 >= prevSma4 && prevSma4 >= prev2Sma4 && sma4 > sma4Middle);

            // === 시그널 계산 ===
            if (type == SMABandType.LongBuy)
            {
                return rawNewLong;
            }
            else if (type == SMABandType.ShortBuy)
            {
                return rawNewShort;
            }

            else if (type == SMABandType.LongSell)
            {
                return rawLongSell;
            }
            else if (type == SMABandType.ShortSell)
            {
                //if (rawShortSell)
                //    firstCloudFlag = true;
                return rawShortSell;

            }
            return false;
        }

        public static double CalculateSMA(List<double> data, int index, int period = 72)
        {
            var result = 0.0;
            for (var i = 0; i < period; i++)
                result += data[index - i];


            return result / period;
        }

        private List<double> GetAvgList(List<double> source, int index, int period, int num)
        {
            var list = new List<double>();

            for (var i = 0; i < period; i++)
            {
                list.Add(CalculateSMA(source, index - i, num));
            }

            return list;
        }

        private double Highest(List<double> source, int index, int period, int num)
        {

            return GetAvgList(source, index, period, 4).Max();

        }

        private double Lowest(List<double> source, int index, int period, int num)
        {
            return GetAvgList(source, index, period, 4).Min();
        }

        private bool IsSideways(List<double> high, List<double> low, int index, bool type, double rangeThresholdPercent)
        {
            double highestHigh = Highest(high, index, rangeLookback, 1);
            double lowestLow = Lowest(low, index, rangeLookback, 1);                

            // long
            if (type)
            {
                double range = high[index] - lowestLow;
                return range > (highestHigh * rangeThresholdPercent / 100.0);
            }
            //short
            else
            {
                double range = highestHigh - low[index];
                return range > (lowestLow * rangeThresholdPercent / 100.0);

            }
        }

        private IchimokuResult GetIchimokuCloud(List<CandleData> candles, int i)
        {
            var highs = candles.Select(t => t.High).ToList();
            var lows = candles.Select(t => t.Low).ToList();
            var closes = candles.Select(t => t.Close).ToList();

            var result = new IchimokuResult();

            double tenkan = 0;
            double kijun = 0;
            double senkouA = 0;
            double senkouB = 0;
            double chikou = 0;

            // Tenkan-sen (9)
            if (i >= 8)
            {
                double max9 = highs.GetRange(i - 8, 9).Max();
                double min9 = lows.GetRange(i - 8, 9).Min();
                tenkan = (max9 + min9) / 2.0;
            }

            // Kijun-sen (26)
            if (i >= 25)
            {
                double max26 = highs.GetRange(i - 25, 26).Max();
                double min26 = lows.GetRange(i - 25, 26).Min();
                kijun = (max26 + min26) / 2.0;
            }

            // Senkou Span A (현재 시점에서 계산만, 시프트는 X)
            if (tenkan != 0 && kijun != 0)
            {
                senkouA = (tenkan + kijun) / 2.0;
            }

            // Senkou Span B (52)
            if (i >= 51)
            {
                double max52 = highs.GetRange(i - 51, 52).Max();
                double min52 = lows.GetRange(i - 51, 52).Min();
                senkouB = (max52 + min52) / 2.0;
            }
            return new IchimokuResult
            {
                TenkanSen = tenkan,
                KijunSen = kijun,
                SenkouSpanA = senkouA,
                SenkouSpanB = senkouB,
                ChikouSpan = chikou
            };

        }
    }
}