using BitgetAPI.Data;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static BitgetAPI.CommonProperty;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.ToolTip;

namespace BitgetApi.IndicatorConditionSetup
{
    public class SMABandConditionSetup
    {
        private readonly int rangeLookback = 12;
        private readonly double rangeThresholdPercent = 0.6;
        private readonly int recentTouchLookback = 5;
        private readonly int recentTouch2Lookback = 15;


        public bool Calculate(List<CandleData> candles, SMABandType type)
        {            
            var close = candles.Select(t => t.Close).ToList();
            close.RemoveAt(close.Count - 1);

            var high = candles.Select(t=>t.High).ToList();
            high.RemoveAt(high.Count - 1);

            var low = candles.Select(t => t.Low).ToList();
            low.RemoveAt(low.Count - 1);

            var open = candles.Select(t => t.Open).ToList();
            open.RemoveAt(open.Count - 1);

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

            // SMA4 관련
            double sma4 = Sma4(close, i);
            double prevSma4 = Sma4(close, i - 1);
            double prev2Sma4 = Sma4(close, i - 2);

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

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

            double prev2Sma4High = Highest(close, i - 2, 12);
            double prev2Sma4Low = Lowest(close, i - 2, 12);
            double prev2Sma4Middle = SMA(close, i - 2, 12);
            bool isSideways = IsSideways(high, low, i);

            // 조건 판단
            bool isLongRecentTouch = IsRecentTouch(close, i, recentTouchLookback, "low");
            bool isShortRecentTouch = IsRecentTouch(close, i, recentTouchLookback, "high");
            bool isShort2RecentTouch = IsMiddleBreakout(close, i, recentTouch2Lookback, true);
            bool isLong2RecentTouch = IsMiddleBreakout(close, i, recentTouch2Lookback, false);

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

            // 진입/청산 조건
            bool rawNewLong = (isSideways && !isLongRecentTouch && isLong2RecentTouch && sma4 == sma4High && prevSma4 < sma4 && prevSma4 == prevSma4High && prev2Sma4 < prev2Sma4High && greenCandle)
                || (isSideways && isLong2RecentTouch && sma4 > sma4Middle && prevSma4 < prevSma4Middle && prevSma4 < sma4 && (sma4Middle - prevSma4Middle) > (prevSma4Middle - SMA(close, i - 2, 12)) && greenCandle);

            bool rawLongSell = close[i] < sma4Middle || (prevSma4High == prevSma4 && sma4High > sma4);

            bool rawNewShort = (sma4 == sma4Low && prevSma4 > sma4 && prevSma4 > prevSma4Low && open[i] > close[i] && ((sma4Middle - prevSma4Middle) < (prevSma4Middle - prev2Sma4Middle)));
            
            bool rawShortSell = close[i] > sma4Middle || (sma4High == sma4 && prevSma4High > prevSma4) || (prev2Sma4Low == prev2Sma4 && prevSma4Low < prevSma4);

            // === 시그널 계산 ===
            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)
            {
                return rawShortSell;

            }
            return false;
        }

        private double Sma4(List<double> list, int index) =>
             Avg(list[index], list[index - 1], list[index - 2], list[index - 3]);

        private double Avg(params double[] values) =>
            values.Average();

        private double SMA(List<double> source, int currentIndex, int period)
        {
            return Enumerable.Range(currentIndex - period + 1, period)
                             .Select(i => Sma4(source, i))
                             .Average();
        }

        private double Highest(List<double> source, int currentIndex, int period)
        {
            return Enumerable.Range(currentIndex - period + 1, period)
                             .Select(i => Sma4(source, i))
                             .Max();
        }

        private double Lowest(List<double> source, int currentIndex, int period)
        {
            return Enumerable.Range(currentIndex - period + 1, period)
                             .Select(i => Sma4(source, i))
                             .Min();
        }

        private bool IsSideways(List<double> high, List<double> low, int index)
        {
            double highestHigh = high.Skip(index - rangeLookback).Take(rangeLookback).Max();
            double lowestLow = low.Skip(index - rangeLookback).Take(rangeLookback).Min();
            double range = highestHigh - lowestLow;
            return range > (highestHigh * rangeThresholdPercent / 100.0);
        }

        private bool IsRecentTouch(List<double> close, int currentIndex, int lookback, string type)
        {
            for (int j = currentIndex - lookback + 1; j <= currentIndex; j++)
            {
                double sma4 = Sma4(close, j);
                double band = (type == "low") ? Lowest(close, j, 12) : Highest(close, j, 12);
                double prevSma4 = Sma4(close, j - 1);
                double prevBand = (type == "low") ? Lowest(close, j - 1, 12) : Highest(close, j - 1, 12);

                if (sma4 >= band && prevSma4 == prevBand)
                    return true;
            }
            return false;
        }

        private bool IsMiddleBreakout(List<double> close, int currentIndex, int lookback, bool above)
        {
            for (int j = currentIndex - lookback + 1; j <= currentIndex; j++)
            {
                double sma4 = Sma4(close, j);
                double middle = SMA(close, j, 12);
                if (above && sma4 > middle) return true;
                if (!above && sma4 < middle) return true;
            }
            return false;
        }
    }
}