BitGet_API/BitgetApi/IndicatorConditionSetup/IndicatorProcess.cs

using BitgetApi.Data;
using BitgetAPI.Data;
using BitgetAPI.IndicatorConditionSetup;
using BitgetAPI.WebService;
using DevExpress.Internal.WinApi.Windows.UI.Notifications;
using DevExpress.Utils.DirectXPaint;
using DevExpress.Utils.IoC;
using DevExpress.Xpo.Logger;
using DevExpress.XtraPrinting.Native;
using Newtonsoft.Json;
using Serilog;
using Serilog.Debugging;
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using static BitgetAPI.CommonProperty;

using static DevExpress.Utils.Drawing.Helpers.NativeMethods;

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

        //영호 Key
        private string YHKIM_AccessKey
        {
            get
            {
                return options.SelectAPI.AccessKey;
            }
        }
        // = "bg_f93aa530288b6ec9d62095994c51972a";
        private string YHKIM_SecreteKey
        {
            get
            {
                return options.SelectAPI.SecretKey;
            }
        }// = "2fce18bcd12ca23a7920c48295a58da031443ea383af8114ed599c1b14ac678e";
        private string YHKIM_PassphraseKey
        {
            get
            {
                return options.SelectAPI.PassphraseKey;
            }
        }// = "dudgh0505";

        private double YHKIM_Leverage
        {
            get
            {
                return options.Leverage;
            }
        }

        private double YHKIM_OrderAmount
        {
            get
            {
                return options.OrderAmount;
            }
        }


        // 스레드 시작/종료 플래그
        public bool Is_th_SignalInfo;
        public Dictionary<string, Dictionary<string, object>> 전저점 = new Dictionary<string, Dictionary<string, object>>();
        public Dictionary<string, Dictionary<string, object>> 전고점 = new Dictionary<string, Dictionary<string, object>>();
        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>> UpBuyList = new Dictionary<string, Dictionary<string, object>>();
        //결과 리스트
        public List<Dictionary<string, object>> UpResultList = new List<Dictionary<string, object>>();

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

        public Dictionary<string, bool> UpList = new Dictionary<string, bool>();
        public Dictionary<string, double> UpBuyValue = new Dictionary<string, double>();

        public Dictionary<string, bool> DownList = new Dictionary<string, bool>();
        public Dictionary<string, double> DownBuyValue = new Dictionary<string, double>();

        public int LongCount = 0;
        public int ShortCount = 0;

        public List<Dictionary<string, object>> BuyLongList = new List<Dictionary<string, object>>();
        public List<Dictionary<string, object>> BuyShortList = new List<Dictionary<string, object>>();
        public List<Dictionary<string, object>> ResultList = new List<Dictionary<string, object>>();

        public Dictionary<string, Dictionary<int, bool>> SellShortStep = new Dictionary<string, Dictionary<int, bool>>();
        public Dictionary<string, Dictionary<int, bool>> SellLongStep = new Dictionary<string, Dictionary<int, bool>>();

        public Dictionary<string, bool> BuyShortStep = new Dictionary<string, bool>();
        public Dictionary<string, bool> BuyLongStep = new Dictionary<string, bool>();




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

        public void calProcess()
        {

            IchimokuConditionSetup ichimokuConditionSetup = new IchimokuConditionSetup();
            MovingAverageConditionSetup movingAverageConditionSetup = new MovingAverageConditionSetup();

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

            //시작시 한번만 하면됨(양방향)
            ChangeFuturePositionMode(FuturePositionMode.hedge_mode);
            //GetFutureAccountList();
            //order 로직
            //var orderDatas = FutureOrder("XRPUSDT", FutureMarginMode.isolated, 10, (double)0.549, FutureSide.BuyShort, OrderType.limit, 10);            

            //var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));
            //var orderValue = new Dictionary<string, object>();
            //orderValue.Add("orderId", orderDic["orderId"]);

            //var sellData = FutureOrder("XRPUSDT", FutureMarginMode.isolated, 10, 0, FutureSide.SellShort, OrderType.market, 10, orderDic["orderId"]);



            // 추후 공통화 및 소스정리 필요
            while (true)
            {
                try
                {
                    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 candleDataList = findedMarket.candleDataList[item.MCandleTimeType].OrderBy(i => i.Argument).ToList();
                        if (candleDataList != null && candleDataList.Count > 0)
                        {
                            var lastCandleData = candleDataList.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);
                        var enumList = Enum.GetValues(typeof(CommonProperty.MCandleTimeType));
                        Array.Reverse(enumList);

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

                            if (!전저점.ContainsKey(market + strInterval))
                            {
                                var dic = new Dictionary<string, object>();
                                dic.Add("val", 0);
                                dic.Add("clearFlag", true);
                                dic.Add("firstFlag", true);
                                dic.Add("flag", false);
                                dic.Add("tempBuyFlag", true);
                                dic.Add("breakFlag", false);
                                전저점.Add(market + strInterval, dic);
                            }
                            if (!전고점.ContainsKey(market + strInterval))
                            {
                                var dic = new Dictionary<string, object>();
                                dic.Add("val", 0);
                                dic.Add("clearFlag", true);
                                dic.Add("firstFlag", true);
                                dic.Add("tempBuyFlag", true);
                                dic.Add("flag", false);
                                dic.Add("breakFlag", false);
                                전고점.Add(market + strInterval, dic);
                            }

                            // 시간별로 정렬하기 (임시 리스트)
                            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);

                            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);

                            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);

                            if (candleData_전전전봉 == null) continue;
                            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 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)
                                {
                                    var price = candleData.Close;
                                    var rate = (candleData.Close / candleData.Open) * 100 - 100;

                                    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 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)
                                {
                                    var price = candleData.Close;
                                    var rate = (candleData.Close / candleData.Open) * 100 - 100;


                                    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 (영호조건식_상향돌파 || 영호조건식_하향돌파)
                            {
                                // 24,72 높은값
                                var 높은값_72_24_전전봉 = Math.Max(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
                                // 24,72 낮은값
                                var 낮은값_72_24_전전봉 = Math.Min(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
                                // 24,72 높은값
                                var 높은값_72_24_전봉 = Math.Max(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);
                                // 24,72 낮은값
                                var 낮은값_72_24_전봉 = Math.Min(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);

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

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

                                var 전전전봉2 = candleData_전전전봉.movingAverageDataList[2].Value;
                                var 전전전봉4 = candleData_전전전봉.movingAverageDataList[4].Value;
                                var 전전전봉8 = candleData_전전전봉.movingAverageDataList[8].Value;
                                var 전전전봉12 = candleData_전전전봉.movingAverageDataList[12].Value;
                                var 전전전봉24 = candleData_전전전봉.movingAverageDataList[24].Value;
                                var 전전전봉36 = candleData_전전전봉.movingAverageDataList[36].Value;
                                var 전전전봉72 = candleData_전전전봉.movingAverageDataList[72].Value;

                                var 전전봉2 = candleData_전전봉.movingAverageDataList[2].Value;
                                var 전전봉4 = candleData_전전봉.movingAverageDataList[4].Value;
                                var 전전봉8 = candleData_전전봉.movingAverageDataList[8].Value;
                                var 전전봉12 = candleData_전전봉.movingAverageDataList[12].Value;
                                var 전전봉24 = candleData_전전봉.movingAverageDataList[24].Value;
                                var 전전봉36 = candleData_전전봉.movingAverageDataList[36].Value;
                                var 전전봉72 = candleData_전전봉.movingAverageDataList[72].Value;

                                var 전봉2 = candleData_전봉.movingAverageDataList[2].Value;
                                var 전봉4 = candleData_전봉.movingAverageDataList[4].Value;
                                var 전봉8 = candleData_전봉.movingAverageDataList[8].Value;
                                var 전봉12 = candleData_전봉.movingAverageDataList[12].Value;
                                var 전봉24 = candleData_전봉.movingAverageDataList[24].Value;
                                var 전봉36 = candleData_전봉.movingAverageDataList[36].Value;
                                var 전봉72 = candleData_전봉.movingAverageDataList[72].Value;

                                var 현재봉2 = candleData.movingAverageDataList[2].Value;
                                var 현재봉4 = candleData.movingAverageDataList[4].Value;
                                var 현재봉8 = candleData.movingAverageDataList[8].Value;
                                var 현재봉12 = candleData.movingAverageDataList[12].Value;
                                var 현재봉24 = candleData.movingAverageDataList[24].Value;
                                var 현재봉36 = candleData.movingAverageDataList[36].Value;
                                var 현재봉72 = candleData.movingAverageDataList[72].Value;


                                var 전봉Bol4_Down = candleData_전봉.movingAverageDataList[4].BolangerValue_Down;
                                var 전봉Bol12_Down = candleData_전봉.movingAverageDataList[12].BolangerValue_Down;
                                var 전봉Bol24_Down = candleData_전봉.movingAverageDataList[24].BolangerValue_Down;

                                var 전전봉Bol4_Down = candleData_전전봉.movingAverageDataList[4].BolangerValue_Down;
                                var 전전봉Bol12_Down = candleData_전전봉.movingAverageDataList[12].BolangerValue_Down;
                                var 전전봉Bol24_Down = candleData_전전봉.movingAverageDataList[24].BolangerValue_Down;

                                var Bol4_Down = candleData.movingAverageDataList[4].BolangerValue_Down;
                                var Bol12_Down = candleData.movingAverageDataList[12].BolangerValue_Down;
                                var Bol24_Down = candleData.movingAverageDataList[24].BolangerValue_Down;

                                var 전봉Bol4_Up = candleData_전봉.movingAverageDataList[4].BolangerValue_Up;
                                var 전봉Bol12_Up = candleData_전봉.movingAverageDataList[12].BolangerValue_Up;
                                var 전봉Bol24_Up = candleData_전봉.movingAverageDataList[24].BolangerValue_Up;

                                var 전전봉Bol4_Up = candleData_전전봉.movingAverageDataList[4].BolangerValue_Up;
                                var 전전봉Bol12_Up = candleData_전전봉.movingAverageDataList[12].BolangerValue_Up;
                                var 전전봉Bol24_Up = candleData_전전봉.movingAverageDataList[24].BolangerValue_Up;

                                var Bol4_Up = candleData.movingAverageDataList[4].BolangerValue_Up;
                                var Bol12_Up = candleData.movingAverageDataList[12].BolangerValue_Up;
                                var Bol24_Up = candleData.movingAverageDataList[24].BolangerValue_Up;

                                if ((int)interval != 1)
                                {
                                    continue;
                                }

                                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));

                                    try
                                    {
                                        //사는 시점
                                        if (!UpBuyList.ContainsKey(market + interval))
                                        {
                                            var buyFlag = false;
                                            var buyType = 0;
                                            if (BuyLongStep.ContainsKey(market + interval) && BuyLongStep[market + interval])
                                            {
                                                if (전봉72 < 전봉24 && 전봉24 < 전봉12 && 전봉12 < 전봉2 && candleData_전봉.IchimokData.상한선 < 전봉24)
                                                {
                                                    if (전봉Bol12_Up < 전봉Bol24_Up && 전전봉Bol12_Up < 전전봉Bol24_Up &&
                                                        전전봉Bol12_Up < 전봉Bol12_Up && 전전봉Bol24_Up < 전봉Bol24_Up)
                                                    {
                                                        buyType = 2;
                                                        buyFlag = true;
                                                    }
                                                }
                                                else if (전봉2 < 전봉24)
                                                    BuyLongStep[market + interval] = false;
                                            }
                                            else
                                            {
                                                if (
                                                    candleData_전봉.IchimokData.하한선 > 전봉2 && candleData_전전봉.IchimokData.하한선 > 전전봉2 &&
                                                    전봉72 > 전봉2 && 전전봉72 > 전전봉2 && 전전봉24 > 전전봉2 && 전봉24 < 전봉2 &&
                                                    전전봉12 < 전전봉2 && 전봉12 < 전봉24
                                                )
                                                {
                                                    //buyFlag = true;
                                                    //buyType = 1;
                                                }
                                                else if (
                                                    candleData_전봉.IchimokData.상한선 < 전봉2 && candleData_전전봉.IchimokData.상한선 < 전전봉2 && candleData_전봉.IchimokData.상한선 < 전봉24 &&
                                                    전봉72 < 전봉2 && 전전봉72 < 전전봉2 && 전전봉24 > 전전봉2 && 전봉24 < 전봉2
                                                )
                                                {
                                                    BuyLongStep[market + interval] = true;
                                                    continue;
                                                }
                                            }


                                            if (buyFlag)
                                            {

                                                // 없으면 생성
                                                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);
                                                }
                                                var buyDic = new Dictionary<string, object>
                                                {
                                                    { "MarketName", market },
                                                    { "BuyDate", nowTime },
                                                    { "Price", price },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "Type", buyType },
                                                    { "CandleTime", candleData.Argument },
                                                    { "MovingRate4_8", 현재봉8 - 현재봉4 },
                                                    { "Candle", candleData }
                                                };

                                                UpBuyList.Add(market + interval, buyDic);

                                                var dic = new Dictionary<int, bool>
                                                {
                                                    [1] = true,
                                                    [2] = false,
                                                    [3] = false,
                                                    [4] = false,
                                                    [5] = false
                                                };
                                                SellLongStep.Add(market + interval, dic);
                                                if (LongCount < 5)
                                                {
                                                    double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
                                                    var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);
                                                    if (orderData != null)
                                                    {
                                                        var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));

                                                        var orderDataDic = new Dictionary<string, object>
                                                        {
                                                            { "MarketName", market },
                                                            { "BuyDate", nowTime },
                                                            { "Price", price },
                                                            { "MCandleTimeType", (int)interval },
                                                            { "Candle", candleData },
                                                            { "Size", size },
                                                            { "orderId", orderDic["orderId"] }
                                                        };
                                                        BuyLongList.Add(orderDataDic);
                                                        LongCount++;
                                                    }
                                                }
                                            }
                                        }
                                        //파는 시점
                                        else
                                        {
                                            var buyItem = UpBuyList[market + interval];

                                            if (interval < MCandleTimeType.H1)
                                            {
                                                var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
                                                if (nowTime < buyTime)
                                                    continue;
                                            }
                                            //임시로 처리
                                            else
                                            {
                                                var buyTime = ((DateTime)buyItem["BuyDate"]).AddHours((int)interval / 60);
                                                if (nowTime < buyTime)
                                                    continue;
                                            }

                                            var sellFlag = false;
                                            int.TryParse(buyItem["Type"].ToString(), out var type);
                                            var val = SellLongStep[market + interval];
                                            switch (type)
                                            {
                                                case 1:
                                                    if (전봉12 > 전봉24 && !val[2])
                                                        val[2] = true;
                                                    if (전봉2 > 전봉72 && !val[3])
                                                        val[3] = true;
                                                    if (전봉12 > 전봉72 && !val[4])
                                                        val[4] = true;
                                                    if (전봉24 > 전봉72 && !val[5])
                                                        val[5] = true;

                                                    if (val[1] && !val[2] && !val[3] && !val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉12 < 전봉24 && 전봉24 < 전봉2 && 전봉2 < 전봉72);
                                                    }
                                                    else if (val[1] && val[2] && !val[3] && !val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉24 < 전봉12 && 전봉12 < 전봉2 && 전봉2 < 전봉72);
                                                    }
                                                    else if (val[1] && !val[2] && val[3] && !val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉12 < 전봉24 && 전봉24 < 전봉72 && 전봉72 < 전봉2);
                                                    }
                                                    else if (val[1] && val[2] && val[3] && !val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉24 < 전봉12 && 전봉12 < 전봉72 && 전봉72 < 전봉2);
                                                    }
                                                    else if (val[1] && val[2] && val[3] && val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉24 < 전봉72 && 전봉72 < 전봉12 && 전봉12 < 전봉2);
                                                    }
                                                    else if (val[1] && val[2] && val[3] && val[4] && val[5])
                                                    {
                                                        sellFlag = !(전봉72 < 전봉24 && 전봉24 < 전봉12 && 전봉12 < 전봉2);
                                                    }
                                                    break;                                               
                                                case 2:
                                                    if (전봉Bol12_Up < 전전봉Bol12_Up && 전봉Bol24_Up < 전전봉Bol24_Up)
                                                    {
                                                        sellFlag = true;
                                                    }
                                                    break;
                                               
                                            }

                                            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"]},
                                                    { "Type", "상향"},
                                                    { "BuyPrice", buyPrice },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "BuyCandle",  buyItem["Candle"] },
                                                    { "SellDate", nowTime},
                                                    { "SellPrice", price },
                                                    { "SellCandle",  candleData },
                                                    { "Rate", resultRate }
                                                };

                                                UpResultList.Add(result);
                                                UpBuyList.Remove(market + interval);
                                                SellLongStep.Remove(market + interval);

                                                var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);

                                                if (orderDic != null)
                                                {
                                                    double.TryParse(orderDic["Size"].ToString(), out var size);
                                                    var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());

                                                    if (sellOrder != null)
                                                    {
                                                        var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
                                                    }
                                                    else
                                                    {
                                                        Log.Error("Sell 안됨 확인 필요");
                                                    }
                                                    double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
                                                    //var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
                                                    //var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));

                                                    //double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);

                                                    var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;

                                                    var orderResult = new Dictionary<string, object>()
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", orderDic["BuyDate"]},
                                                        { "BuyPrice", orderDic["Price"] },
                                                        { "Type", "상향"},
                                                        { "MCandleTimeType", (int)interval },
                                                        { "BuyCandle",  buyItem["Candle"] },
                                                        { "SellDate", nowTime},
                                                        { "SellPrice", price},
                                                        { "SellCandle",  candleData },
                                                        { "Rate", resultRateData }
                                                    };
                                                    ResultList.Add(orderResult);
                                                    BuyLongList.Remove(orderDic);
                                                    LongCount--;
                                                }

                                            }
                                        }

                                    }
                                    catch (Exception e)
                                    {

                                    }
                                }
                                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));

                                    try
                                    {
                                        //사는 시점
                                        if (!DownBuyList.ContainsKey(market + interval))
                                        {
                                            var buyFlag = false;
                                            var buyType = 0;

                                            if (BuyShortStep.ContainsKey(market + interval) && BuyShortStep[market + interval])
                                            {
                                                //72 > 24 > 12 > 2
                                                if (전봉72 > 전봉24 && 전봉24 > 전봉12 && 전봉12 > 전봉2 && candleData_전봉.IchimokData.하한선 > 전봉24)
                                                {
                                                    if (전봉Bol12_Down > 전봉Bol24_Down && 전전봉Bol12_Down > 전전봉Bol24_Down &&
                                                        전전봉Bol12_Down > 전봉Bol12_Down && 전전봉Bol24_Down > 전봉Bol24_Down)
                                                    {
                                                        buyType = 2;
                                                        buyFlag = true;
                                                    }
                                                }
                                                else if (전봉2 > 전봉24)
                                                    BuyShortStep[market + interval] = false;
                                            }
                                            else
                                            {
                                                if (
                                                    candleData_전봉.IchimokData.상한선 < 전봉2 && candleData_전전봉.IchimokData.상한선 < 전전봉2 &&
                                                    전봉72 < 전봉2 && 전전봉72 < 전전봉2 && 전전봉24 < 전전봉2 && 전봉24 > 전봉2 &&
                                                    전전봉12 > 전전봉2 && 전봉12 > 전봉24
                                                )
                                                {
                                                    //buyFlag = true;
                                                    //buyType = 1;
                                                }
                                                else if (
                                                    candleData_전봉.IchimokData.하한선 > 전봉2 && candleData_전전봉.IchimokData.하한선 > 전전봉2 && candleData_전봉.IchimokData.하한선 > 전봉24 &&
                                                    전봉72 > 전봉2 && 전전봉72 > 전전봉2 && 전전봉24 < 전전봉2 && 전봉24 > 전봉2
                                                )
                                                {
                                                    BuyShortStep[market + interval] = true;
                                                    continue;
                                                }
                                            }                                            
                                            if (buyFlag)
                                            {

                                                // 없으면 생성
                                                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);
                                                }
                                                var buyDic = new Dictionary<string, object>
                                                {
                                                    { "MarketName", market },
                                                    { "BuyDate", nowTime },
                                                    { "Price", price },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "Type", buyType },
                                                    { "CandleTime", candleData.Argument },
                                                    { "MovingRate4_8", 현재봉4 - 현재봉8 },
                                                    { "Candle", candleData }
                                                };

                                                DownBuyList.Add(market + interval, buyDic);
                                                var dic = new Dictionary<int, bool>
                                                {
                                                    [1] = true,
                                                    [2] = false,
                                                    [3] = false,
                                                    [4] = false,
                                                    [5] = false
                                                };
                                                SellShortStep.Add(market + interval, dic);
                                                if(buyType == 2)
                                                {
                                                    BuyShortStep[market + interval] = false;
                                                }
                                                if (ShortCount < 5)
                                                {
                                                    double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
                                                    var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);
                                                    if (orderData != null)
                                                    {
                                                        var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));

                                                        var orderDataDic = new Dictionary<string, object>
                                                         {
                                                            { "MarketName", market },
                                                            { "BuyDate", nowTime },
                                                            { "Price", price },
                                                            { "MCandleTimeType", (int)interval },
                                                            { "Candle", candleData },
                                                            { "Size", size },
                                                            { "orderId", orderDic["orderId"] }
                                                        };
                                                        BuyShortList.Add(orderDataDic);
                                                        ShortCount++;
                                                    }
                                                }
                                            }
                                        }
                                        //파는 시점
                                        else
                                        {
                                            var sellFlag = false;
                                            var buyItem = DownBuyList[market + interval];

                                            if (interval < MCandleTimeType.H1)
                                            {
                                                var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
                                                if (nowTime < buyTime)
                                                    continue;
                                            }
                                            //임시로 처리
                                            else
                                            {
                                                var buyTime = ((DateTime)buyItem["BuyDate"]).AddHours((int)interval / 60);
                                                if (nowTime < buyTime)
                                                    continue;
                                            }

                                            int.TryParse(buyItem["Type"].ToString(), out var type);
                                            
                                            switch (type)
                                            {
                                                case 1:
                                                    var val = SellShortStep[market + interval];
                                                    if (전봉12 < 전봉24 && !val[2])
                                                        val[2] = true;
                                                    if (전봉2 < 전봉72 && !val[3])
                                                        val[3] = true;
                                                    if (전봉12 < 전봉72 && !val[4])
                                                        val[4] = true;
                                                    if (전봉24 < 전봉72 && !val[5])
                                                        val[5] = true;

                                                    if (val[1] && !val[2] && !val[3] && !val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉12 > 전봉24 && 전봉24 > 전봉2 && 전봉2 > 전봉72);
                                                    }
                                                    else if (val[1] && val[2] && !val[3] && !val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉24 > 전봉12 && 전봉12 > 전봉2 && 전봉2 > 전봉72);
                                                    }
                                                    else if (val[1] && !val[2] && val[3] && !val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉12 > 전봉24 && 전봉24 > 전봉72 && 전봉72 >전봉2);
                                                    }
                                                    else if (val[1] && val[2] && val[3] && !val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉24 > 전봉12 && 전봉12 > 전봉72 && 전봉72 > 전봉2);
                                                    }
                                                    else if (val[1] && val[2] && val[3] && val[4] && !val[5])
                                                    {
                                                        sellFlag = !(전봉24 > 전봉72 && 전봉72 > 전봉12 && 전봉12 > 전봉2);
                                                    }
                                                    else if (val[1] && val[2] && val[3] && val[4] && val[5])
                                                    {
                                                        sellFlag = !(전봉72 > 전봉24 && 전봉24 > 전봉12 && 전봉12 > 전봉2);
                                                    }
                                                    else
                                                        sellFlag = true;
                                                    break;
                                                case 2:
                                                    if(전봉Bol12_Down > 전전봉Bol12_Down && 전봉Bol24_Down > 전전봉Bol24_Down)
                                                    {
                                                        sellFlag = true;
                                                    }
                                                    break;
                                            }

                                            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 },
                                                    { "Type", "하향"},
                                                    { "MCandleTimeType", (int)interval },
                                                    { "BuyCandle",  buyItem["Candle"] },
                                                    { "SellDate", nowTime},
                                                    { "SellPrice", price },
                                                    { "SellCandle",  candleData },
                                                    { "Rate", resultRate }
                                                };

                                                DownResultList.Add(result);
                                                DownBuyList.Remove(market + interval);
                                                SellShortStep.Remove(market + interval);
                                                var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);

                                                if (orderDic != null)
                                                {
                                                    double.TryParse(orderDic["Size"].ToString(), out var size);
                                                    var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());

                                                    if (sellOrder != null)
                                                    {
                                                        var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
                                                    }
                                                    else
                                                    {
                                                        Log.Error("Sell 안됨 확인 필요");
                                                    }


                                                    double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
                                                    //var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
                                                    //var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));

                                                    //double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);

                                                    var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;

                                                    var orderResult = new Dictionary<string, object>()
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", orderDic["BuyDate"]},
                                                        { "BuyPrice", orderDic["Price"] },
                                                        { "Type", "하향"},
                                                        { "MCandleTimeType", (int)interval },
                                                        { "BuyCandle",  buyItem["Candle"] },
                                                        { "SellDate", nowTime},
                                                        { "SellPrice", price },
                                                        { "SellCandle",  candleData },
                                                        { "Rate", resultRateData }
                                                    };
                                                    ResultList.Add(orderResult);
                                                    BuyShortList.Remove(orderDic);
                                                    ShortCount--;
                                                }
                                            }
                                        }
                                    }
                                    catch (Exception e)
                                    {
                                        Console.WriteLine(e.Message);
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
            }
        }

        public Dictionary<string, object> GetPendingOrders()
        {
            var timestamp = GetTimeStamp().ToString();

            var reqStr = "/api/v2/mix/order/orders-pending";

            var nvc = new NameValueCollection {
                {"ACCESS-KEY", YHKIM_AccessKey},
                {"ACCESS-SIGN", GenerateSignString(timestamp, "GET", reqStr, "productType=USDT-FUTURES", null, YHKIM_SecreteKey) },
                {"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
                {"ACCESS-TIMESTAMP",timestamp}
            };

            return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetPendingOrder_Future, BitgetURL_PendingOrders_Future, null, MCandleTimeType.M1, "", "", nvc);
        }

        public long GetTimeStamp()
        {

            var result = (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetGetTimeStamp, BitgetURL_GetTimestamp, null, MCandleTimeType.M1, "", "", null);
            if (result == null)
            {
                return 0;
            }
            var data = JsonConvert.DeserializeObject<Dictionary<string, object>>(JsonConvert.SerializeObject(result["data"]));
            long.TryParse(data["serverTime"].ToString(), out var returnData);
            return returnData;
        }


        public List<Dictionary<string, object>> GetFutureAccountList()
        {


            var timestamp = GetTimeStamp().ToString();

            var reqStr = "/api/v2/mix/account/accounts";

            var nvc = new NameValueCollection {
                {"ACCESS-KEY", YHKIM_AccessKey},
                {"ACCESS-SIGN", GenerateSignString(timestamp, "GET", reqStr, "productType=USDT-FUTURES", null, YHKIM_SecreteKey) },
                {"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
                {"ACCESS-TIMESTAMP",timestamp}
            };

            return (List<Dictionary<string, object>>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetAccountList_Future, BitgetURL_AccountList_Future, null, MCandleTimeType.M1, "", "", nvc);
        }

        public Dictionary<string, object> CancelFutureOrder(string symbol, string orderId)
        {


            var timestamp = GetTimeStamp().ToString();

            var reqStr = "/api/v2/mix/order/cancel-order";
            var postStr = "{\"symbol\" : \"" + symbol + "\", \"orderId\" : \"" + orderId + "\", \"productType\" : \"usdt-futures\" , \"marginCoin\" : \"USDT\"}";
            var nvc = new NameValueCollection {
                {"ACCESS-KEY", YHKIM_AccessKey},
                {"ACCESS-SIGN",  GenerateSignString(timestamp, "POST", reqStr, "", postStr, YHKIM_SecreteKey)},
                {"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
                {"ACCESS-TIMESTAMP", timestamp}
            };

            return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetCancelOrder_Future, BitgetURL_CancelOrder_Future, null, MCandleTimeType.M1, postStr, "", nvc);
        }

        public Dictionary<string, object> ChangeFuturePositionMode(FuturePositionMode mode)
        {


            var timestamp = GetTimeStamp().ToString();

            var reqStr = "/api/v2/mix/account/set-position-mode";
            var postStr = "{\"productType\" : \"USDT-FUTURES\", \"posMode\" : \"" + Utils.Convertor.GetEnumDescription((Enum)mode) + "\"}";

            var nvc = new NameValueCollection {
                {"ACCESS-KEY", YHKIM_AccessKey},
                {"ACCESS-SIGN",  GenerateSignString(timestamp, "POST", reqStr, "", postStr, YHKIM_SecreteKey)},
                {"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
                {"ACCESS-TIMESTAMP", timestamp}
            };

            return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetChangePositionMode_Future, BitgetURL_ChangePositionMode_Future, null, MCandleTimeType.M1, postStr, "", nvc);
        }

        public Dictionary<string, object> GetFutureOrderDetail(string symbol, string orderId)
        {

            var timestamp = GetTimeStamp().ToString();

            // sell은 ClientOID 가 필요
            var orderDetailStr = "/api/v2/mix/order/detail";
            timestamp = GetTimeStamp().ToString();
            var orderDetailnvc = new NameValueCollection {
                    {"ACCESS-KEY", YHKIM_AccessKey},
                    {"ACCESS-SIGN", GenerateSignString(timestamp, "GET", orderDetailStr, "symbol="+symbol.ToString()+"&orderId="+orderId.ToString()+"&productType=USDT-FUTURES", null, YHKIM_SecreteKey) },
                    {"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
                    {"ACCESS-TIMESTAMP",timestamp}
                };

            return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetOrderDetail_Future, BitgetURL_OrderDetail_Future + "?symbol=" + symbol.ToString() + "&orderId=" + orderId.ToString() + "&productType=USDT-FUTURES", null, MCandleTimeType.M1, "", "", orderDetailnvc);

        }


        public Dictionary<string, object> FutureOrder(string symbol, FutureMarginMode marginMode, double size, double price, FutureSide futureSide, OrderType orderType, double leverage, string id = "")
        {
            var side = "";
            var tradeSide = "";

            if (futureSide == FutureSide.BuyShort)
            {
                id = Guid.NewGuid().ToString();
                side = "sell";
                tradeSide = "open";
            }
            else if (futureSide == FutureSide.BuyLong)
            {
                id = Guid.NewGuid().ToString();
                side = "buy";
                tradeSide = "Open";
            }
            else if (futureSide == FutureSide.SellShort)
            {
                side = "sell";
                tradeSide = "close";
            }
            else if (futureSide == FutureSide.SellLong)
            {
                side = "buy";
                tradeSide = "close";
            }

            if (orderType == OrderType.market)
                price = 0;



            var timestamp = GetTimeStamp().ToString();

            var reqStr = "/api/v2/mix/order/place-order";

            if (futureSide == FutureSide.BuyShort || futureSide == FutureSide.BuyLong)
            {
                //change margin mode 이후 leverage 처리 해야 함
                var changeMarginModeStr = "{\"symbol\": \"" + symbol + "\", \"productType\": \"usdt-futures\", \"marginCoin\": \"USDT\", \"marginMode\": \"" + Utils.Convertor.GetEnumDescription((Enum)marginMode) + "\"}";

                var nvcMargin = new NameValueCollection {
                    {"ACCESS-KEY", YHKIM_AccessKey},
                    {"ACCESS-SIGN",  GenerateSignString(timestamp, "POST", "/api/v2/mix/account/set-margin-mode", "", changeMarginModeStr, YHKIM_SecreteKey)},
                    {"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
                    {"ACCESS-TIMESTAMP", timestamp}
                };
                var result = (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetChangeMarginMode_Future, BitgetURL_ChangeMarginMode_Future, null, MCandleTimeType.M1, changeMarginModeStr, "", nvcMargin);
                if (result == null || result["msg"]?.ToString() != "success")
                {
                    return null;
                }

                var leverageStr = "{\"symbol\": \"" + symbol + "\", \"productType\": \"USDT-FUTURES\", \"marginCoin\": \"USDT\", \"leverage\": \"" + leverage.ToString() + "\", \"holdSide\": \"" + (futureSide == FutureSide.BuyShort ? "short" : "long") + "\"}";
                timestamp = GetTimeStamp().ToString();
                var nvcLeverage = new NameValueCollection {
                    {"ACCESS-KEY",  YHKIM_AccessKey},
                    {"ACCESS-SIGN",  GenerateSignString(timestamp, "POST", "/api/v2/mix/account/set-leverage", "", leverageStr, YHKIM_SecreteKey)},
                    {"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
                    {"ACCESS-TIMESTAMP", timestamp}
                };
                result = (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetChangeLeverage_Future, BitgetURL_ChangeLeverage_Future, null, MCandleTimeType.M1, leverageStr, "", nvcLeverage);
                if (result == null || result["msg"]?.ToString() != "success")
                {
                    return null;
                }
            }
            else
            {
                var result = CancelFutureOrder(symbol, id);
                if (result == null || result["msg"]?.ToString() != "success")
                {
                    Log.Error("Sell에서 Cancel관련 Error");
                }
            }

            var postStr = "{\"symbol\": \"" + symbol + "\", \"productType\": \"usdt-futures\", \"marginMode\": \"" + Utils.Convertor.GetEnumDescription((Enum)marginMode) + "\", \"marginCoin\": \"USDT\", \"size\": \""
                + size.ToString() + "\", \"price\": \"" + price.ToString() + "\", \"side\": \"" + side + "\", " + "\"tradeSide\": \"" + tradeSide + "\", \"orderType\": \"" + Utils.Convertor.GetEnumDescription((Enum)orderType)
                + "\", \"force\": \"gtc\", \"clientOid\": \"" + id + "\" }";
            timestamp = GetTimeStamp().ToString();
            var nvc = new NameValueCollection {
                {"ACCESS-KEY", YHKIM_AccessKey},
                {"ACCESS-SIGN",  GenerateSignString(timestamp, "POST", reqStr, "", postStr, YHKIM_SecreteKey)},
                {"ACCESS-PASSPHRASE", YHKIM_PassphraseKey },
                {"ACCESS-TIMESTAMP", timestamp}
            };
            return (Dictionary<string, object>)WebConnection.SendWebServer(ExchangeWebReqType.BitgetOrder_Future, BitgetURL_BuySellOrder_Future, null, MCandleTimeType.M1, postStr, "", nvc);
        }

        public string GenerateSignString(string timestamp, string method, string requestPath, string queryString, string body, string secretKey)
        {
            method = method.ToUpper();
            body = body == null ? "" : body;
            queryString = string.IsNullOrWhiteSpace(queryString) ? "" : "?" + queryString;
            string preHash = timestamp + method + requestPath + queryString + body;

            var encSecretKey_byteData = System.Text.Encoding.UTF8.GetBytes(secretKey);
            var encPreHash_byteData = System.Text.Encoding.UTF8.GetBytes(preHash);

            return Convert.ToBase64String(new HMACSHA256(encSecretKey_byteData).ComputeHash(encPreHash_byteData));
        }

        public void calIchimokuProcess_Add()
        {


        }

        public void calIchimokuProcess_Update()
        {

        }
    }
}

/*
if (영호조건식_상향돌파 || 영호조건식_하향돌파)
                            {
                                var 전봉4 = candleData_전봉.movingAverageDataList[4].Value;
                                var 전봉8 = candleData_전봉.movingAverageDataList[8].Value;
                                var 전봉24 = candleData_전봉.movingAverageDataList[24].Value;
                                var 전봉48 = candleData_전봉.movingAverageDataList[48].Value;
                                var 전봉72 = candleData_전봉.movingAverageDataList[72].Value;
                                
                                var 전전봉4 = candleData_전전봉.movingAverageDataList[4].Value;
                                var 전전봉8 = candleData_전전봉.movingAverageDataList[8].Value;
                                var 전전봉24 = candleData_전전봉.movingAverageDataList[24].Value;
                                var 전전봉48 = candleData_전전봉.movingAverageDataList[48].Value;
                                var 전전봉72 = candleData_전전봉.movingAverageDataList[72].Value;

                                var 현재봉4 = candleData.movingAverageDataList[4].Value;
                                var 현재봉8 = candleData.movingAverageDataList[8].Value;
                                var 현재봉12 = candleData.movingAverageDataList[12].Value;
                                var 현재봉24 = candleData.movingAverageDataList[24].Value;
                                var 현재봉48 = candleData.movingAverageDataList[48].Value;
                                var 현재봉72 = candleData.movingAverageDataList[72].Value;

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

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

                                if ((int)interval != 1)
                                {
                                    continue;
                                }

                                #region 5분봉 처리
                                //15분봉이지만 60분봉으로 변경
                                //var candleDatas5 = findedMarket.candleDataList[MCandleTimeType.M5].ToList();
                                //var candleDatas5_정렬 = candleDatas5.OrderBy(i => i.Argument).ToList();

                                //var candleData5 = candleDatas5.FirstOrDefault(i => i.Argument == candleDatas5_정렬.Last().Argument);
                                //if (candleData5 == null) continue;
                                //movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas5_정렬, candleData5);
                                //ichimokuConditionSetup.calIchimokuData(candleDatas5_정렬, candleData5);


                                //candleDatas5_정렬.RemoveAt(candleDatas5_정렬.Count - 1);
                                //var candleData5_전봉 = candleDatas5.FirstOrDefault(i => i.Argument == candleDatas5_정렬.Last().Argument);
                                //movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas5_정렬, candleData5_전봉);
                                //ichimokuConditionSetup.calIchimokuData(candleDatas5_정렬, candleData5_전봉);

                                //var 현재봉5_4 = candleData5.movingAverageDataList[4].Value;
                                //var 전봉5_4 = candleData5_전봉.movingAverageDataList[4].Value;

                                #endregion

                                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));

                                    try
                                    {   
                                        if (!UpBuyList.ContainsKey(market + interval))
                                        {
                                            if (
                                                candleData.IchimokData.하한선 > 현재봉4 &&
                                                candleData_전봉.IchimokData.하한선 > candleData_전봉.Close &&
                                                candleData_전봉.Open < candleData_전봉.Close &&                                                
                                                전봉4 > 전봉8 && 전전봉4 < 전전봉8 &&
                                                전봉8 < 전봉24 && 전봉24 < 전봉48 && 전봉48 < 전봉72 &&
                                                전전봉8 < 전전봉24 && 전전봉24 < 전전봉48 && 전전봉48 < 전전봉72 &&
                                                전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24 && 전전봉Bol4 > 전봉Bol4
                                            ) {
                                                
                                                // 없으면 생성
                                                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);
                                                }
                                                var buyDic = new Dictionary<string, object>
                                                {
                                                    { "MarketName", market },
                                                    { "BuyDate", nowTime },
                                                    { "Price", price },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "Candle", candleData }
                                                };

                                                UpBuyList.Add(market + interval, buyDic);
                                                SellLongStep.Add(market + interval, 8);

                                                if (LongCount < 2)
                                                {
                                                    double size =  YHKIM_OrderAmount / price * YHKIM_Leverage;
                                                    var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);

                                                    if (orderData == null)
                                                    {
                                                        Log.Error("Buy 안됨 확인 필요");
                                                        continue;
                                                    }

                                                    var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));

                                                    var orderDataDic = new Dictionary<string, object>
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", nowTime },
                                                        { "Price", price },
                                                        { "MCandleTimeType", (int)interval },
                                                        { "Candle", candleData },
                                                        { "Size", size },
                                                        { "orderId", orderDic["orderId"] }
                                                    };
                                                    BuyLongList.Add(orderDataDic);
                                                    LongCount++;

                                                    
                                                }

                                            }
                                        }
                                        //파는 시점
                                        else
                                        {
                                            var buyItem = UpBuyList[market + interval];
                                            if (interval < MCandleTimeType.H1)
                                            {
                                                if ((nowTime.Minute == 0 ? 60 : nowTime.Minute) < ((DateTime)buyItem["BuyDate"]).Minute + (int)interval)
                                                {
                                                    continue;
                                                }
                                            }
                                            //임시로 처리
                                            else
                                            {
                                                if ((nowTime.Hour == 0 ? 24 : nowTime.Hour) < ((DateTime)buyItem["BuyDate"]).Hour + ((int)interval / 60))
                                                {
                                                    continue;
                                                }
                                            }

                                            var key = SellLongStep[market + interval];
                                            var sellFlag = false;
                                            switch (SellLongStep[market + interval])
                                            {
                                                case 8:
                                                    if (전봉8 > 전봉24)
                                                    {
                                                        SellLongStep[market + interval] = 24;
                                                        key = 24;
                                                    }
                                                    else
                                                    {
                                                        if (전봉4 < 전전봉4)
                                                        {
                                                            sellFlag = true;
                                                        }

                                                        else if ((nowTime.Minute == 0 ? 60 : nowTime.Minute) < ((DateTime)buyItem["BuyDate"]).Minute + (int)interval * 2)
                                                        {
                                                            if (전봉4 > candleData_전봉.Close && 전봉4 < 전봉24)
                                                            {
                                                                sellFlag = true;
                                                            }
                                                        }

                                                        if (현재봉4 < 현재봉8 && candleData.Close < candleData.movingAverageDataList[key].Value) sellFlag = true;
                                                    }
                                                    break;
                                                case 24:
                                                    if (전봉8 > 전봉48)
                                                    {
                                                        SellLongStep[market + interval] = 48;
                                                        key = 48;
                                                    }
                                                    break;
                                                case 48:
                                                    key = 8;
                                                    break;                                              
                                            }

                                            
                                            if (candleData.movingAverageDataList[key].Value > 현재봉4 || 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"]},
                                                    { "Type", "상향"},
                                                    { "BuyPrice", buyPrice },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "BuyCandle",  buyItem["Candle"] },
                                                    { "SellDate", nowTime},
                                                    { "SellPrice", price },
                                                    { "SellCandle",  candleData },
                                                    { "Rate", resultRate }
                                                };

                                                UpResultList.Add(result);
                                                UpBuyList.Remove(market + interval);
                                                SellLongStep.Remove(market + interval);                                                

                                                var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);

                                                if (orderDic != null)
                                                {
                                                    double.TryParse(orderDic["Size"].ToString(), out var size);
                                                    var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());

                                                    if (sellOrder != null)
                                                    {
                                                        var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
                                                    }
                                                    else
                                                    {
                                                        Log.Error("Sell 안됨 확인 필요");
                                                    }
                                                    double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
                                                    //var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
                                                    //var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));

                                                    //double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);

                                                    var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;

                                                    var orderResult = new Dictionary<string, object>()
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", orderDic["BuyDate"]},
                                                        { "BuyPrice", orderDic["Price"] },
                                                        { "Type", "상향"},
                                                        { "MCandleTimeType", (int)interval },
                                                        { "BuyCandle",  buyItem["Candle"] },
                                                        { "SellDate", nowTime},
                                                        { "SellPrice", price},
                                                        { "SellCandle",  candleData },
                                                        { "Rate", resultRateData }
                                                    };
                                                    ResultList.Add(orderResult);
                                                    BuyLongList.Remove(orderDic);
                                                    LongCount--;
                                                }

                                            }
                                        }

                                    }
                                    catch (Exception e)
                                    {

                                    }
                                }
                                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));

                                    try
                                    {
                                        //사는 시점
                                        if (!DownBuyList.ContainsKey(market + interval))
                                        {
                                            if (
                                                candleData.IchimokData.상한선 < 현재봉4 &&
                                                candleData_전봉.IchimokData.상한선 < candleData_전봉.Close &&
                                                candleData_전봉.Open > candleData_전봉.Close &&                                               
                                                전봉4 < 전봉8 && 전전봉4 > 전전봉8 &&
                                                전봉8 > 전봉24 && 전봉24 > 전봉48 && 전봉48 > 전봉72 &&
                                                전전봉8 > 전전봉24 && 전전봉24 > 전전봉48 && 전전봉48 > 전전봉72 &&
                                                전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24 && 전전봉Bol4 > 전봉Bol4
                                                )
                                            {
                                                
                                                // 없으면 생성
                                                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);
                                                }
                                                var buyDic = new Dictionary<string, object>
                                                {
                                                    { "MarketName", market },
                                                    { "BuyDate", nowTime },
                                                    { "Price", price },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "Candle", candleData }
                                                };

                                                DownBuyList.Add(market + interval, buyDic);

                                                
                                                if(ShortCount < 2)
                                                {
                                                    double size =  YHKIM_OrderAmount / price * YHKIM_Leverage;
                                                    var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);

                                                    if (orderData == null) {
                                                        Log.Error("Buy 안됨 확인 필요");
                                                        continue;
                                                    }
                                                    
                                                    var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));                                                                                                       

                                                    var orderDataDic = new Dictionary<string, object>
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", nowTime },
                                                        { "Price", price },
                                                        { "MCandleTimeType", (int)interval },
                                                        { "Candle", candleData },
                                                        { "Size", size },
                                                        { "orderId", orderDic["orderId"] }
                                                    };
                                                    BuyShortList.Add(orderDataDic);
                                                    ShortCount++;
                                                    SellShortStep.Add(market + interval, 8);
                                                }
                                            }
                                        }
                                        //파는 시점
                                        else
                                        {
                                            var buyItem = DownBuyList[market + interval];
                                            if (interval < MCandleTimeType.H1)
                                            {
                                                if ((nowTime.Minute == 0 ? 60 : nowTime.Minute) < ((DateTime)buyItem["BuyDate"]).Minute + (int)interval)
                                                {
                                                    continue;
                                                }
                                            }
                                            //임시로 처리
                                            else
                                            {
                                                if ((nowTime.Hour == 0 ? 24 : nowTime.Hour) < ((DateTime)buyItem["BuyDate"]).Hour + ((int)interval / 60))
                                                {
                                                    continue;
                                                }
                                            }

                                            var key = SellShortStep[market + interval];
                                            var sellFlag = false;
                                            switch (SellShortStep[market + interval])
                                            {
                                                case 8:
                                                    if (전봉8 < 전봉24)
                                                    {
                                                        SellShortStep[market + interval] = 24;
                                                        key = 24;
                                                    }
                                                    else
                                                    {
                                                        if (전봉4 > 전전봉4)
                                                        {
                                                            sellFlag = true;
                                                        }
                                                        else if ((nowTime.Minute == 0 ? 60 : nowTime.Minute) < ((DateTime)buyItem["BuyDate"]).Minute + (int)interval * 2)
                                                        {
                                                            if (전봉4 < candleData_전봉.Close && 전봉4 > 전봉24)
                                                            {
                                                                sellFlag = true;
                                                            }
                                                        }

                                                        if (현재봉4 > 현재봉8 && candleData.Close > candleData.movingAverageDataList[key].Value) sellFlag = true;
                                                    }

                                                    break;
                                                case 24:
                                                    if (전봉8 < 전봉48)
                                                    {
                                                        SellShortStep[market + interval] = 48;
                                                        key = 48;
                                                    }
                                                    break;
                                                case 48:                                                    
                                                    key = 8;
                                                    break;
                                               
                                            }
                                           
                                            if (candleData.movingAverageDataList[key].Value < 현재봉4 || 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 },
                                                    { "Type", "하향"},
                                                    { "MCandleTimeType", (int)interval },
                                                    { "BuyCandle",  buyItem["Candle"] },
                                                    { "SellDate", nowTime},
                                                    { "SellPrice", price },
                                                    { "SellCandle",  candleData },
                                                    { "Rate", resultRate }
                                                };

                                                DownResultList.Add(result);
                                                DownBuyList.Remove(market + interval);
                                                SellShortStep.Remove(market + interval);
                                                var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);

                                                if (orderDic != null)
                                                {
                                                    double.TryParse(orderDic["Size"].ToString(), out var size);
                                                    var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());

                                                    if (sellOrder != null)
                                                    {
                                                        var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
                                                    }
                                                    else
                                                    {
                                                        Log.Error("Sell 안됨 확인 필요");
                                                    }


                                                    double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
                                                    //var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
                                                    //var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));

                                                    //double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);

                                                    var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;

                                                    var orderResult = new Dictionary<string, object>()
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", orderDic["BuyDate"]},
                                                        { "BuyPrice", orderDic["Price"] },
                                                        { "Type", "하향"},
                                                        { "MCandleTimeType", (int)interval },
                                                        { "BuyCandle",  buyItem["Candle"] },
                                                        { "SellDate", nowTime},
                                                        { "SellPrice", price },
                                                        { "SellCandle",  candleData },
                                                        { "Rate", resultRateData }
                                                    };
                                                    ResultList.Add(orderResult);
                                                    BuyShortList.Remove(orderDic);
                                                    ShortCount--;
                                                }
                                            }
                                        }
                                    }
                                    catch (Exception e)
                                    {
                                        Console.WriteLine(e.Message);
                                    }
                                }
                            } 

 */
/*
 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 높은값_48_24_전전봉 = Math.Max(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
                                // 24,72 낮은값
                                var 낮은값_48_24_전전봉 = Math.Min(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
                                // 24,72 높은값
                                var 높은값_48_24_전봉 = Math.Max(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);
                                // 24,72 낮은값
                                var 낮은값_48_24_전봉 = Math.Min(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);

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

                                var 높은값_12_낮은값72_24 = Math.Max(candleData.movingAverageDataList[12].Value, 낮은값_48_24);
                                var 낮은값_12_높은값72_24 = Math.Min(candleData.movingAverageDataList[12].Value, 높은값_48_24);

                                var 전전봉4 = candleData_전전봉.movingAverageDataList[4].Value;
                                var 전전봉12 = candleData_전전봉.movingAverageDataList[12].Value;
                                var 전전봉24 = candleData_전전봉.movingAverageDataList[24].Value;
                                var 전전봉72 = candleData_전전봉.movingAverageDataList[72].Value;

                                var 전봉4 = candleData_전봉.movingAverageDataList[4].Value;
                                var 전봉12 = candleData_전봉.movingAverageDataList[12].Value;
                                var 전봉24 = candleData_전봉.movingAverageDataList[24].Value;
                                var 전봉72 = candleData_전봉.movingAverageDataList[72].Value;

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


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

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

                                //5분봉이 default이지만 15분봉으로 변경
                                if ((int)interval != 5)
                                {
                                    continue;
                                }

                                #region 15분봉 처리
                                //15분봉이지만 60분봉으로 변경
                                var candleDatas15 = findedMarket.candleDataList[MCandleTimeType.M15];
                                var candleDatas15_정렬 = candleDatas15.ToList().OrderBy(i => i.Argument).ToList();

                                var candleData15 = candleDatas15.Find(i => i.Argument == candleDatas15_정렬.Last().Argument);
                                if (candleData15 == null) continue;
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas15_정렬, candleData15);
                                ichimokuConditionSetup.calIchimokuData(candleDatas15_정렬, candleData15);


                                candleDatas15_정렬.RemoveAt(candleDatas15_정렬.Count - 1);
                                var candleData15_전봉 = candleDatas15.Find(i => i.Argument == candleDatas15_정렬.Last().Argument);
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas15_정렬, candleData15_전봉);
                                ichimokuConditionSetup.calIchimokuData(candleDatas15_정렬, candleData15_전봉);

                                candleDatas15_정렬.RemoveAt(candleDatas15_정렬.Count - 1);
                                var candleData15_전전봉 = candleDatas15.Find(i => i.Argument == candleDatas15_정렬.Last().Argument);
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas15_정렬, candleData15_전전봉);
                                ichimokuConditionSetup.calIchimokuData(candleDatas15_정렬, candleData15_전전봉);

                                candleDatas15_정렬.RemoveAt(candleDatas15_정렬.Count - 1);
                                var candleData15_전전전봉 = candleDatas15.Find(i => i.Argument == candleDatas15_정렬.Last().Argument);
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas15_정렬, candleData15_전전봉);
                                ichimokuConditionSetup.calIchimokuData(candleDatas15_정렬, candleData15_전전봉);


                                var 낮은값15_72_24 = Math.Min(candleData15.movingAverageDataList[72].Value, candleData15.movingAverageDataList[24].Value);
                                var 높은값15_72_24 = Math.Max(candleData15.movingAverageDataList[72].Value, candleData15.movingAverageDataList[24].Value);

                                var 전봉낮은값15_72_24 = Math.Min(candleData15_전봉.movingAverageDataList[72].Value, candleData15_전봉.movingAverageDataList[24].Value);
                                var 전봉높은값15_72_24 = Math.Max(candleData15_전봉.movingAverageDataList[72].Value, candleData15_전봉.movingAverageDataList[24].Value);
                                var 전전봉낮은값15_72_24 = Math.Min(candleData15_전봉.movingAverageDataList[72].Value, candleData15_전봉.movingAverageDataList[24].Value);
                                var 전전봉높은값15_72_24 = Math.Max(candleData15_전봉.movingAverageDataList[72].Value, candleData15_전봉.movingAverageDataList[24].Value);

                                var 현재봉15_12 = candleData15.movingAverageDataList[12].Value;
                                var 전봉15_12 = candleData15_전봉.movingAverageDataList[12].Value;
                                var 전전봉15_12 = candleData15_전전봉.movingAverageDataList[12].Value;

                                var 현재봉15_4 = candleData15.movingAverageDataList[4].Value;
                                var 전봉15_4 = candleData15_전봉.movingAverageDataList[4].Value;
                                var 전전봉15_4 = candleData15_전전봉.movingAverageDataList[4].Value;

                                var 전봉15Bol4 = candleData15_전봉.movingAverageDataList[4].BolangerValue;
                                var 전봉15Bol12 = candleData15_전봉.movingAverageDataList[12].BolangerValue;
                                var 전봉15Bol24 = candleData15_전봉.movingAverageDataList[24].BolangerValue;

                                var 전전봉15Bol4 = candleData15_전전봉.movingAverageDataList[4].BolangerValue;
                                var 전전봉15Bol12 = candleData15_전전봉.movingAverageDataList[12].BolangerValue;
                                var 전전봉15Bol24 = candleData15_전전봉.movingAverageDataList[24].BolangerValue;
                                var 현재봉15Bol4 = candleData15.movingAverageDataList[4].BolangerValue;
                                var 현재봉15Bol12 = candleData15.movingAverageDataList[12].BolangerValue;
                                var 현재봉15Bol24 = candleData15.movingAverageDataList[24].BolangerValue;
                                #endregion

                                #region 1분봉 처리
                                //1분봉이지만 3분봉으로 변경
                                var candleDatas1 = findedMarket.candleDataList[MCandleTimeType.M1];
                                var candleDatas1_정렬 = candleDatas1.ToList().OrderBy(i => i.Argument).ToList();

                                var candleData1 = candleDatas1.Find(i => i.Argument == candleDatas1_정렬.Last().Argument);
                                if (candleData1 == null) continue;
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas1_정렬, candleData1);
                                ichimokuConditionSetup.calIchimokuData(candleDatas1_정렬, candleData1);

                                candleDatas1_정렬.RemoveAt(candleDatas1_정렬.Count - 1);
                                var candleData1_전봉 = candleDatas1.Find(i => i.Argument == candleDatas1_정렬.Last().Argument);
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas1_정렬, candleData1_전봉);
                                ichimokuConditionSetup.calIchimokuData(candleDatas1_정렬, candleData1_전봉);

                                candleDatas1_정렬.RemoveAt(candleDatas1_정렬.Count - 1);
                                var candleData1_전전봉 = candleDatas1.Find(i => i.Argument == candleDatas1_정렬.Last().Argument);
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas1_정렬, candleData1_전전봉);
                                ichimokuConditionSetup.calIchimokuData(candleDatas1_정렬, candleData1_전전봉);


                                var 높은값1_72_24 = Math.Max(candleData1.movingAverageDataList[72].Value, candleData1.movingAverageDataList[24].Value);
                                var 낮은값1_72_24 = Math.Min(candleData1.movingAverageDataList[72].Value, candleData1.movingAverageDataList[24].Value);

                                var 전봉낮은값1_72_24 = Math.Min(candleData1_전봉.movingAverageDataList[72].Value, candleData1_전봉.movingAverageDataList[24].Value);
                                var 전봉높은값1_72_24 = Math.Max(candleData1_전봉.movingAverageDataList[72].Value, candleData1_전봉.movingAverageDataList[24].Value);
                                var 전전봉낮은값1_72_24 = Math.Min(candleData1_전전봉.movingAverageDataList[72].Value, candleData1_전전봉.movingAverageDataList[24].Value);
                                var 전전봉높은값1_72_24 = Math.Max(candleData1_전전봉.movingAverageDataList[72].Value, candleData1_전전봉.movingAverageDataList[24].Value);

                                var 현재봉1_12 = candleData1.movingAverageDataList[12].Value;
                                var 전봉1_12 = candleData1_전봉.movingAverageDataList[12].Value;
                                var 전전봉1_12 = candleData1_전전봉.movingAverageDataList[12].Value;

                                var 현재봉1_4 = candleData1.movingAverageDataList[4].Value;
                                var 전봉1_4 = candleData1_전봉.movingAverageDataList[4].Value;
                                var 전전봉1_4 = candleData1_전전봉.movingAverageDataList[4].Value;

                                var 전봉1Bol4 = candleData1_전봉.movingAverageDataList[4].BolangerValue;
                                var 전봉1Bol12 = candleData1_전봉.movingAverageDataList[12].BolangerValue;
                                var 전봉1Bol24 = candleData1_전봉.movingAverageDataList[24].BolangerValue;

                                var 전전봉1Bol4 = candleData1_전전봉.movingAverageDataList[4].BolangerValue;
                                var 전전봉1Bol12 = candleData1_전전봉.movingAverageDataList[12].BolangerValue;
                                var 전전봉1Bol24 = candleData1_전전봉.movingAverageDataList[24].BolangerValue;
                                var 현재봉1Bol4 = candleData1.movingAverageDataList[4].BolangerValue;
                                var 현재봉1Bol12 = candleData1.movingAverageDataList[12].BolangerValue;
                                var 현재봉1Bol24 = candleData1.movingAverageDataList[24].BolangerValue;
                                #endregion

                                #region 60분봉 처리
                                //60분봉이지만 180분 처리
                                var candleDatas60 = findedMarket.candleDataList[MCandleTimeType.H1];
                                var candleDatas60_정렬 = candleDatas60.ToList().OrderBy(i => i.Argument).ToList();

                                var candleData60 = candleDatas60.Find(i => i.Argument == candleDatas60_정렬.Last().Argument);
                                if (candleData60 == null) continue;
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas60_정렬, candleData60);
                                ichimokuConditionSetup.calIchimokuData(candleDatas60_정렬, candleData60);


                                candleDatas60_정렬.RemoveAt(candleDatas60_정렬.Count - 1);
                                var candleData60_전봉 = candleDatas60.Find(i => i.Argument == candleDatas60_정렬.Last().Argument);
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas60_정렬, candleData60_전봉);
                                ichimokuConditionSetup.calIchimokuData(candleDatas60_정렬, candleData60_전봉);

                                candleDatas60_정렬.RemoveAt(candleDatas60_정렬.Count - 1);
                                var candleData60_전전봉 = candleDatas60.Find(i => i.Argument == candleDatas60_정렬.Last().Argument);
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas60_정렬, candleData60_전전봉);
                                ichimokuConditionSetup.calIchimokuData(candleDatas60_정렬, candleData60_전전봉);

                                candleDatas60_정렬.RemoveAt(candleDatas60_정렬.Count - 1);
                                var candleData60_전전전봉 = candleDatas60.Find(i => i.Argument == candleDatas60_정렬.Last().Argument);
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas60_정렬, candleData60_전전전봉);
                                ichimokuConditionSetup.calIchimokuData(candleDatas60_정렬, candleData60_전전전봉);


                                var 낮은값60_72_24 = Math.Min(candleData60.movingAverageDataList[72].Value, candleData60.movingAverageDataList[24].Value);
                                var 높은값60_72_24 = Math.Max(candleData60.movingAverageDataList[72].Value, candleData60.movingAverageDataList[24].Value);

                                var 전봉낮은값60_72_24 = Math.Min(candleData60_전봉.movingAverageDataList[72].Value, candleData60_전봉.movingAverageDataList[24].Value);
                                var 전봉높은값60_72_24 = Math.Max(candleData60_전봉.movingAverageDataList[72].Value, candleData60_전봉.movingAverageDataList[24].Value);
                                var 전전봉낮은값60_72_24 = Math.Min(candleData60_전봉.movingAverageDataList[72].Value, candleData60_전봉.movingAverageDataList[24].Value);
                                var 전전봉높은값60_72_24 = Math.Max(candleData60_전봉.movingAverageDataList[72].Value, candleData60_전봉.movingAverageDataList[24].Value);

                                var 현재봉60_12 = candleData60.movingAverageDataList[12].Value;
                                var 전봉60_12 = candleData60_전봉.movingAverageDataList[12].Value;
                                var 전전봉60_12 = candleData60_전전봉.movingAverageDataList[12].Value;

                                var 현재봉60_4 = candleData60.movingAverageDataList[4].Value;
                                var 전봉60_4 = candleData60_전봉.movingAverageDataList[4].Value;
                                var 전전봉60_4 = candleData60_전전봉.movingAverageDataList[4].Value;

                                var 전봉60Bol4 = candleData60_전봉.movingAverageDataList[4].BolangerValue;
                                var 전봉60Bol12 = candleData60_전봉.movingAverageDataList[12].BolangerValue;
                                var 전봉60Bol24 = candleData60_전봉.movingAverageDataList[24].BolangerValue;

                                var 전전봉60Bol4 = candleData60_전전봉.movingAverageDataList[4].BolangerValue;
                                var 전전봉60Bol12 = candleData60_전전봉.movingAverageDataList[12].BolangerValue;
                                var 전전봉60Bol24 = candleData60_전전봉.movingAverageDataList[24].BolangerValue;
                                var 현재봉60Bol4 = candleData60.movingAverageDataList[4].BolangerValue;
                                var 현재봉60Bol12 = candleData60.movingAverageDataList[12].BolangerValue;
                                var 현재봉60Bol24 = candleData60.movingAverageDataList[24].BolangerValue;
                                #endregion

                                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));

                                    try
                                    {
                                        var candle15Flag = 현재봉15_4 > 현재봉15_12
                                             && candleData15.Open < candleData15.Close
                                            && 현재봉15_4 > 전봉15_4
                                             && 전봉15_4 > 전전봉15_4
                                            && 현재봉15_12 > 전봉15_12
                                             && 전봉15_12 > 전전봉15_12
                                            && 전봉15Bol12 - 전봉15Bol24 > 현재봉15Bol12 - 현재봉15Bol24;

                                        var candle60Flag = 현재봉60_4 > 현재봉60_12
                                            // && candleData60.Open < candleData60.Close 
                                            && 현재봉60_4 > 전봉60_4
                                             //&& 전봉60_4 > 전전봉60_4
                                            && 현재봉60_12 > 전봉60_12
                                            // && 전봉60_12 > 전전봉60_12 
                                            && 전봉60Bol12 - 전봉60Bol24 > 현재봉60Bol12 - 현재봉60Bol24;


                                        var buyFlag = 전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24 && 전전봉Bol4 > 전봉Bol4;
                                        var sellFlag = 현재봉1_4 < 높은값1_72_24;

                                        var 전고점Data = 전고점[market + strInterval];
                                        double.TryParse(전고점Data["val"].ToString(), out var val);
                                        bool.TryParse(전고점Data["flag"].ToString(), out var flag);
                                        bool.TryParse(전고점Data["firstFlag"].ToString(), out var firstFlag);
                                        bool.TryParse(전고점Data["clearFlag"].ToString(), out var clearFlag);
                                        bool.TryParse(전고점Data["breakFlag"].ToString(), out var breakFlag);
                                        bool.TryParse(전고점Data["tempBuyFlag"].ToString(), out var tempBuyFlag);

                                        if (현재봉4 < 낮은값_48_24 && candleData.IchimokData.하한선 > candleData.Close)
                                        {
                                            if (firstFlag)
                                                전고점Data["firstFlag"] = false;

                                            전고점Data["flag"] = true;
                                            전고점Data["clearFlag"] = true;
                                            전고점Data["val"] = 0;
                                            전고점Data["breakFlag"] = false;
                                            전고점Data["tempBuyFlag"] = true;
                                        }

                                        if (!flag || !breakFlag)
                                        {
                                            if (val == 0)
                                            {
                                                전고점Data["val"] = 전봉4;
                                                val = 전봉4;
                                            }

                                            if (전봉4 < 전전봉4 && clearFlag)
                                            {
                                                전고점Data["clearFlag"] = false;
                                                if (전전봉4 < val)
                                                {
                                                    전고점Data["flag"] = false;
                                                    전고점Data["breakFlag"] = true;
                                                }
                                                else
                                                {
                                                    전고점Data["flag"] = true;
                                                }
                                            }

                                            else if (전봉4 > 전전봉4)
                                            {
                                                전고점Data["clearFlag"] = true;
                                                if (val < 전봉4)
                                                {
                                                    전고점Data["val"] = 전봉4;
                                                }
                                            }
                                        }
                                        if (전전봉4 > 낮은값_48_24_전전봉
                                                && 전전봉4 < 높은값_48_24_전전봉
                                                && 전봉4 < 낮은값_48_24_전봉
                                                && 전봉12 > 낮은값_48_24_전봉)
                                        {
                                            if (UpList.ContainsKey(market + strInterval))
                                            {
                                                if (UpList[market + strInterval])
                                                    UpList[market + strInterval] = false;
                                            }
                                            else
                                            {
                                                UpList.Add(market + strInterval, false);
                                            }
                                        }

                                        if ((
                                                전전봉4 > 낮은값_48_24_전전봉
                                                && 전전봉4 < 높은값_48_24_전전봉
                                                && 전봉4 < 낮은값_48_24_전봉
                                                && 전봉12 > 낮은값_48_24_전봉
                                                && 전봉24 < 전전봉24
                                                && 전봉12 < 전전봉12
                                                && 전봉4 < 전전봉4
                                                && (!UpBuyValue.ContainsKey(market + strInterval) || (UpBuyValue.ContainsKey(market + strInterval) && UpBuyValue[market + strInterval] == 0))
                                                //&& 낮은값_48_24_전봉 < candleData_전봉.IchimokData.상한선
                                                //&& candleData_전봉.Close < candleData_전봉.IchimokData.상한선
                                                //&& candleData_전봉.Open > candleData_전봉.Close
                                                ))
                                        {
                                            if (UpBuyValue.ContainsKey(market + strInterval) && UpBuyValue[market + strInterval] == 0)
                                            {
                                                UpBuyValue[market + strInterval] = candleData.Open;
                                            }
                                            else
                                            {
                                                UpBuyValue.Add(market + strInterval, candleData.Open);
                                            }
                                        }
                                        else if (UpBuyValue.ContainsKey(market + strInterval) && UpBuyValue[market + strInterval] != 0 && 현재봉1_4 > 높은값1_72_24 && UpList.ContainsKey(market + strInterval) && !UpList[market + strInterval])
                                        {
                                            if (UpBuyValue[market + strInterval] < candleData.Close)
                                            {
                                                if (UpList.ContainsKey(market + strInterval))
                                                {
                                                    UpList[market + strInterval] = true;
                                                }
                                                else
                                                {
                                                    UpList.Add(market + strInterval, true);
                                                }

                                            }

                                            UpBuyValue[market + strInterval] = 0;
                                        }

                                        //사는 시점
                                        if (!UpBuyList.ContainsKey(market + interval))
                                        {
                                            if (
                                                (
                                                전전봉4 < 높은값_48_24_전전봉
                                                && 전전봉4 > 낮은값_48_24_전전봉
                                                && 전봉4 > 높은값_48_24_전봉
                                                && 전봉12 < 높은값_48_24_전봉
                                                && 전봉24 > 전전봉24
                                                && 전봉12 > 전전봉12
                                                && 전봉4 > 전전봉4
                                                && 높은값_48_24_전봉 > candleData_전봉.IchimokData.하한선
                                                && candleData_전봉.Close > candleData_전봉.IchimokData.하한선
                                                && candleData_전봉.Open < candleData_전봉.Close
                                                )
                                                && flag && !firstFlag && buyFlag && tempBuyFlag
                                                && UpList.ContainsKey(market + strInterval) && UpList[market + strInterval]

                                                //4 < 높은값_72_24_전전봉 &&
                                                //전봉4 > 높은값_72_24_전봉 &&
                                                //전봉12 > 전전봉12 &&
                                                //((전봉4 < candleData_전봉.IchimokData.하한선 && 높은값_72_24_전봉 < candleData_전봉.IchimokData.하한선)
                                                //|| (전봉4 > candleData_전봉.IchimokData.하한선 && 높은값_72_24_전봉 > candleData_전봉.IchimokData.하한선)) &&
                                                //전봉4 - 전전봉4 > 전봉12 - 전전봉12 &&
                                                //전봉12 - 전전봉12 > 전봉24 - 전전봉24
                                                //)
                                                //&& flag && !firstFlag && buyFlag && candle15Flag

                                                )
                                            {
                                                전고점Data["tempBuyFlag"] = false;

                                                if (!(candle15Flag && candle60Flag))
                                                    continue;

                                                // 없으면 생성
                                                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);
                                                }
                                                var buyDic = new Dictionary<string, object>
                                                {
                                                    { "MarketName", market },
                                                    { "BuyDate", nowTime },
                                                    { "Price", price },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "Candle", candleData }
                                                };

                                                UpBuyList.Add(market + interval, buyDic);

                                                if (val == 0)
                                                    전고점Data["val"] = 전봉4;

                                                전고점Data["flag"] = false;
                                                전고점Data["clearFlag"] = false;


                                                if (LongCount < 3)
                                                {
                                                    double size =  YHKIM_OrderAmount / price * YHKIM_Leverage;
                                                    var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);
                                                    var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));

                                                    var orderDataDic = new Dictionary<string, object>
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", nowTime },
                                                        { "Price", price },
                                                        { "MCandleTimeType", (int)interval },
                                                        { "Candle", candleData },
                                                        { "Size", size },
                                                        { "orderId", orderDic["orderId"] }
                                                    };
                                                    BuyLongList.Add(orderDataDic);
                                                    LongCount++;
                                                }

                                            }
                                        }
                                        //파는 시점
                                        else
                                        {
                                            var buyItem = UpBuyList[market + interval];
                                            if (interval < MCandleTimeType.H1)
                                            {
                                                if (nowTime < ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval))
                                                {
                                                    continue;
                                                }
                                            }
                                            //임시로 처리
                                            else
                                            {
                                                if (nowTime < ((DateTime)buyItem["BuyDate"]).AddHours(((int)interval) / 60))
                                                {
                                                    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"]},
                                                    { "Type", "상향"},
                                                    { "BuyPrice", buyPrice },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "BuyCandle",  buyItem["Candle"] },
                                                    { "SellDate", nowTime},
                                                    { "SellPrice", price },
                                                    { "SellCandle",  candleData },
                                                    { "Rate", resultRate }
                                                };

                                                UpResultList.Add(result);
                                                UpBuyList.Remove(market + interval);

                                                var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);

                                                if (orderDic != null)
                                                {
                                                    double.TryParse(orderDic["Size"].ToString(), out var size);
                                                    var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());

                                                    if (sellOrder != null)
                                                    {
                                                        var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
                                                    }
                                                    else
                                                    {
                                                        Log.Error("Sell 안됨 확인 필요");
                                                    }
                                                    double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
                                                    //var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
                                                    //var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));

                                                    //double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);

                                                    var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;

                                                    var orderResult = new Dictionary<string, object>()
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", orderDic["BuyDate"]},
                                                        { "BuyPrice", orderDic["Price"] },
                                                        { "Type", "상향"},
                                                        { "MCandleTimeType", (int)interval },
                                                        { "BuyCandle",  buyItem["Candle"] },
                                                        { "SellDate", nowTime},
                                                        { "SellPrice", price},
                                                        { "SellCandle",  candleData },
                                                        { "Rate", resultRateData }
                                                    };
                                                    ResultList.Add(orderResult);
                                                    BuyLongList.Remove(orderDic);
                                                    LongCount--;
                                                }

                                            }
                                        }

                                    }
                                    catch (Exception e)
                                    {

                                    }
                                }
                                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));

                                    try
                                    {
                                        var candle15Flag = 현재봉15_4 < 현재봉15_12
                                            && candleData15.Open > candleData15.Close
                                            && 현재봉15_4 < 전봉15_4
                                            && 전봉15_4 < 전전봉15_4
                                            && 현재봉15_12 < 전봉15_12
                                          && 전봉15_12 < 전전봉15_12
                                            && 전봉15Bol12 - 전봉15Bol24 > 현재봉15Bol12 - 현재봉15Bol24;


                                        var candle60Flag = 현재봉60_4 < 현재봉12
                                            // && candleData60.Open > candleData60.Close 
                                            && 현재봉60_4 < 전봉60_4 
                                           // && 전봉60_4 < 전전봉60_4
                                            && 현재봉60_12 < 전봉60_12
                                            //&& 전봉60_12 < 전전봉60_12 
                                            && 전봉60Bol12 - 전봉60Bol24 > 현재봉60Bol12 - 현재봉60Bol24;

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

                                        var sellFlag = 현재봉1_4 > 높은값1_72_24;

                                        var 전저점Data = 전저점[market + strInterval];
                                        double.TryParse(전저점Data["val"].ToString(), out var val);
                                        bool.TryParse(전저점Data["flag"].ToString(), out var flag);
                                        bool.TryParse(전저점Data["firstFlag"].ToString(), out var firstFlag);
                                        bool.TryParse(전저점Data["clearFlag"].ToString(), out var clearFlag);
                                        bool.TryParse(전저점Data["breakFlag"].ToString(), out var breakFlag);
                                        bool.TryParse(전저점Data["tempBuyFlag"].ToString(), out var tempBuyFlag);

                                        if (현재봉4 > 높은값_48_24 && candleData.IchimokData.상한선 < candleData.Close)
                                        {
                                            if (firstFlag)
                                                전저점Data["firstFlag"] = false;

                                            전저점Data["flag"] = true;
                                            전저점Data["clearFlag"] = true;
                                            전저점Data["val"] = 0;
                                            전저점Data["breakFlag"] = false;
                                            전저점Data["tempBuyFlag"] = true;
                                        }

                                        if (!flag || !breakFlag)
                                        {
                                            if (val == 0)
                                            {
                                                전저점Data["val"] = 전봉4;
                                                val = 전봉4;
                                            }

                                            if (전봉4 > 전전봉4 && clearFlag)
                                            {
                                                전저점Data["clearFlag"] = false;
                                                if (전전봉4 > val)
                                                {
                                                    전저점Data["flag"] = false;
                                                    전저점Data["breakFlag"] = true;
                                                }
                                                else
                                                {
                                                    전저점Data["flag"] = true;
                                                }
                                            }

                                            else if (전봉4 < 전전봉4)
                                            {
                                                전저점Data["clearFlag"] = true;
                                                if (val > 전봉4)
                                                {
                                                    전저점Data["val"] = 전봉4;
                                                }
                                            }
                                        }
                                        if (전전봉4 < 높은값_48_24_전전봉
                                            && 전전봉4 > 낮은값_48_24_전전봉
                                            && 전봉4 > 높은값_48_24_전봉
                                            && 전봉12 < 높은값_48_24_전봉)
                                        {

                                            if (DownList.ContainsKey(market + strInterval))
                                            {
                                                if (DownList[market + strInterval])
                                                    DownList[market + strInterval] = false;
                                            }
                                            else
                                            {
                                                DownList.Add(market + strInterval, false);
                                            }
                                        }

                                        if ((
                                            전전봉4 < 높은값_48_24_전전봉
                                            && 전전봉4 > 낮은값_48_24_전전봉
                                            && 전봉4 > 높은값_48_24_전봉
                                            && 전봉12 < 높은값_48_24_전봉
                                            && 전봉24 > 전전봉24 && 전봉12 > 전전봉12
                                            && 전봉4 > 전전봉4
                                            && (!DownBuyValue.ContainsKey(market + strInterval) || (DownBuyValue.ContainsKey(market + strInterval) && DownBuyValue[market + strInterval] == 0))
                                            //&& 높은값_48_24_전봉 > candleData_전봉.IchimokData.하한선
                                            //&& candleData_전봉.Close > candleData_전봉.IchimokData.하한선
                                            //&& candleData_전봉.Open < candleData_전봉.Close
                                            ))
                                        {
                                            if (DownBuyValue.ContainsKey(market + strInterval) && DownBuyValue[market + strInterval] == 0)
                                            {
                                                DownBuyValue[market + strInterval] = candleData.Open;
                                            }
                                            else
                                            {
                                                DownBuyValue.Add(market + strInterval, candleData.Open);
                                            }
                                        }
                                        else if (DownBuyValue.ContainsKey(market + strInterval) && DownBuyValue[market + strInterval] != 0 && 현재봉1_4 < 낮은값1_72_24 && DownList.ContainsKey(market + strInterval) && !DownList[market + strInterval])
                                        {
                                            if (DownBuyValue[market + strInterval] > candleData.Close)
                                            {
                                                if (DownList.ContainsKey(market + strInterval))
                                                {
                                                    DownList[market + strInterval] = true;
                                                }
                                                else
                                                {
                                                    DownList.Add(market + strInterval, true);
                                                }

                                            }

                                            DownBuyValue[market + strInterval] = 0;
                                        }

                                        //사는 시점
                                        if (!DownBuyList.ContainsKey(market + interval))
                                        {
                                            if ((
                                                전전봉4 > 낮은값_48_24_전전봉
                                                && 전전봉4 < 높은값_48_24_전전봉
                                                && 전봉4 < 낮은값_48_24_전봉
                                                && 전봉12 > 낮은값_48_24_전봉
                                                && 전봉24 < 전전봉24
                                                && 전봉12 < 전전봉12
                                                && 전봉4 < 전전봉4
                                                && 낮은값_48_24_전봉 < candleData_전봉.IchimokData.상한선
                                                && candleData_전봉.Close < candleData_전봉.IchimokData.상한선
                                                && candleData_전봉.Open > candleData_전봉.Close
                                                )
                                                && flag && !firstFlag && buyFlag && tempBuyFlag
                                                 && DownList.ContainsKey(market + strInterval) && DownList[market + strInterval]
                                                )
                                            {
                                                전저점Data["tempBuyFlag"] = false;
                                                if (!(candle15Flag && candle60Flag))
                                                    continue;

                                                // 없으면 생성
                                                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);
                                                }
                                                var buyDic = new Dictionary<string, object>
                                                {
                                                    { "MarketName", market },
                                                    { "BuyDate", nowTime },
                                                    { "Price", price },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "Candle", candleData }
                                                };

                                                DownBuyList.Add(market + interval, buyDic);

                                                if (val == 0)
                                                    전저점Data["val"] = 전봉4;

                                                전저점Data["flag"] = false;
                                                전저점Data["clearFlag"] = false;

                                                if(ShortCount < 2)
                                                {
                                                    double size =  YHKIM_OrderAmount / price * YHKIM_Leverage;
                                                    var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);
                                                    var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));                                                                                                       

                                                    var orderDataDic = new Dictionary<string, object>
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", nowTime },
                                                        { "Price", price },
                                                        { "MCandleTimeType", (int)interval },
                                                        { "Candle", candleData },
                                                        { "Size", size },
                                                        { "orderId", orderDic["orderId"] }
                                                    };
                                                    BuyShortList.Add(orderDataDic);
                                                    ShortCount++;
                                                }
                                            }
                                        }
                                        //파는 시점
                                        else
                                        {
                                            var buyItem = DownBuyList[market + interval];
                                            if (interval < MCandleTimeType.H1)
                                            {
                                                if (nowTime < ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval))
                                                {
                                                    continue;
                                                }
                                            }
                                            //임시로 처리
                                            else
                                            {
                                                if (nowTime < ((DateTime)buyItem["BuyDate"]).AddHours(((int)interval) / 60))
                                                {
                                                    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 },
                                                    { "Type", "하향"},
                                                    { "MCandleTimeType", (int)interval },
                                                    { "BuyCandle",  buyItem["Candle"] },
                                                    { "SellDate", nowTime},
                                                    { "SellPrice", price },
                                                    { "SellCandle",  candleData },
                                                    { "Rate", resultRate }
                                                };

                                                DownResultList.Add(result);
                                                DownBuyList.Remove(market + interval);

                                                var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);

                                                if (orderDic != null)
                                                {
                                                    double.TryParse(orderDic["Size"].ToString(), out var size);
                                                    var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());

                                                    if (sellOrder != null)
                                                    {
                                                        var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
                                                    }
                                                    else
                                                    {
                                                        Log.Error("Sell 안됨 확인 필요");
                                                    }


                                                    double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
                                                    //var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
                                                    //var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));

                                                    //double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);

                                                    var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;

                                                    var orderResult = new Dictionary<string, object>()
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", orderDic["BuyDate"]},
                                                        { "BuyPrice", orderDic["Price"] },
                                                        { "Type", "하향"},
                                                        { "MCandleTimeType", (int)interval },
                                                        { "BuyCandle",  buyItem["Candle"] },
                                                        { "SellDate", nowTime},
                                                        { "SellPrice", price },
                                                        { "SellCandle",  candleData },
                                                        { "Rate", resultRateData }
                                                    };
                                                    ResultList.Add(orderResult);
                                                    BuyShortList.Remove(orderDic);
                                                    ShortCount--;
                                                }
                                            }
                                        }
                                    }
                                    catch (Exception e)
                                    {
                                        Console.WriteLine(e.Message);
                                    }
                                }
                            }
 */
/*
if (영호조건식_상향돌파 || 영호조건식_하향돌파)
                            {
                                // 24,72 높은값
                                var 높은값_72_24_전전봉 = Math.Max(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
                                // 24,72 낮은값
                                var 낮은값_72_24_전전봉 = Math.Min(candleData_전전봉.movingAverageDataList[72].Value, candleData_전전봉.movingAverageDataList[24].Value);
                                // 24,72 높은값
                                var 높은값_72_24_전봉 = Math.Max(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);
                                // 24,72 낮은값
                                var 낮은값_72_24_전봉 = Math.Min(candleData_전봉.movingAverageDataList[72].Value, candleData_전봉.movingAverageDataList[24].Value);

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

                                var 전전봉4 = candleData_전전봉.movingAverageDataList[4].Value;
                                var 전전봉8 = candleData_전전봉.movingAverageDataList[8].Value;
                                var 전전봉12 = candleData_전전봉.movingAverageDataList[12].Value;
                                var 전전봉24 = candleData_전전봉.movingAverageDataList[24].Value;
                                var 전전봉72 = candleData_전전봉.movingAverageDataList[72].Value;

                                var 전봉4 = candleData_전봉.movingAverageDataList[4].Value;
                                var 전봉8 = candleData_전봉.movingAverageDataList[8].Value;
                                var 전봉12 = candleData_전봉.movingAverageDataList[12].Value;
                                var 전봉24 = candleData_전봉.movingAverageDataList[24].Value;
                                var 전봉72 = candleData_전봉.movingAverageDataList[72].Value;

                                var 현재봉4 = candleData.movingAverageDataList[4].Value;
                                var 현재봉8 = candleData.movingAverageDataList[8].Value;
                                var 현재봉12 = candleData.movingAverageDataList[12].Value;
                                var 현재봉24 = candleData.movingAverageDataList[24].Value;
                                var 현재봉72 = candleData.movingAverageDataList[72].Value;


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

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

                                if ((int)interval != 15)
                                {
                                    continue;
                                }


                                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));

                                    try
                                    {
                                        //사는 시점
                                        if (!UpBuyList.ContainsKey(market + interval))
                                        {
                                            if (
                                                (
                                                    전전봉4 < 높은값_72_24_전전봉 &&
                                                    전봉4 > 높은값_72_24_전봉
                                                    && 전봉8 < 높은값_72_24_전봉
                                                    && 전봉12 < 높은값_72_24_전봉
                                                    && 전봉4 > 전전봉4
                                                    && 전봉8 > 전전봉8
                                                    && 전봉12 > 전전봉12
                                                    && 전봉4 > candleData_전봉.IchimokData.하한선
                                                )
                                            )
                                            {

                                                // 없으면 생성
                                                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);
                                                }
                                                var buyDic = new Dictionary<string, object>
                                                {
                                                    { "MarketName", market },
                                                    { "BuyDate", nowTime },
                                                    { "Price", price },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "Candle", candleData }
                                                };

                                                UpBuyList.Add(market + interval, buyDic);
                                                SellLongStep.Add(market + interval, 0);
                                                if (LongCount < 5)
                                                {
                                                    double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
                                                    var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyLong, OrderType.limit, YHKIM_Leverage);
                                                    if (orderData != null)
                                                    {
                                                        var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));

                                                        var orderDataDic = new Dictionary<string, object>
                                                        {
                                                            { "MarketName", market },
                                                            { "BuyDate", nowTime },
                                                            { "Price", price },
                                                            { "MCandleTimeType", (int)interval },
                                                            { "Candle", candleData },
                                                            { "Size", size },
                                                            { "orderId", orderDic["orderId"] }
                                                        };
                                                        BuyLongList.Add(orderDataDic);
                                                        LongCount++;
                                                    }
                                                }
                                            }
                                        }
                                        //파는 시점
                                        else
                                        {
                                            var buyItem = UpBuyList[market + interval];
                                            if (interval < MCandleTimeType.H1)
                                            {
                                                var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
                                                if (nowTime < buyTime)
                                                    continue;
                                            }
                                            //임시로 처리
                                            else
                                            {
                                                var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
                                                if (nowTime < buyTime)
                                                    continue;
                                            }

                                            var compareVal = 높은값_72_24;
                                            var val = SellLongStep[market + interval];
                                            var sellFlag = false;
                                            
                                            if (val != 101)
                                            {
                                                if (높은값_72_24 < 현재봉8)
                                                {
                                                    SellLongStep[market + interval] = 101;
                                                    val = 101;
                                                }
                                            }

                                            if (val == 101)
                                            {
                                                compareVal = 현재봉8;
                                            }

                                            if (candleData_전봉.Close < candleData_전봉.Open &&
                                                candleData_전전봉.Close < candleData_전전봉.Open &&
                                                candleData_전전전봉.Close < candleData_전전전봉.Open)
                                                sellFlag = true;

                                            if (현재봉4 < compareVal || 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"]},
                                                    { "Type", "상향"},
                                                    { "BuyPrice", buyPrice },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "BuyCandle",  buyItem["Candle"] },
                                                    { "SellDate", nowTime},
                                                    { "SellPrice", price },
                                                    { "SellCandle",  candleData },
                                                    { "Rate", resultRate }
                                                };

                                                UpResultList.Add(result);
                                                UpBuyList.Remove(market + interval);
                                                SellLongStep.Remove(market + interval);

                                                var orderDic = BuyLongList.FirstOrDefault(t => t["MarketName"].ToString() == market);

                                                if (orderDic != null)
                                                {
                                                    double.TryParse(orderDic["Size"].ToString(), out var size);
                                                    var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellLong, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());

                                                    if (sellOrder != null)
                                                    {
                                                        var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
                                                    }
                                                    else
                                                    {
                                                        Log.Error("Sell 안됨 확인 필요");
                                                    }
                                                    double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
                                                    //var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
                                                    //var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));

                                                    //double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);

                                                    var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;

                                                    var orderResult = new Dictionary<string, object>()
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", orderDic["BuyDate"]},
                                                        { "BuyPrice", orderDic["Price"] },
                                                        { "Type", "상향"},
                                                        { "MCandleTimeType", (int)interval },
                                                        { "BuyCandle",  buyItem["Candle"] },
                                                        { "SellDate", nowTime},
                                                        { "SellPrice", price},
                                                        { "SellCandle",  candleData },
                                                        { "Rate", resultRateData }
                                                    };
                                                    ResultList.Add(orderResult);
                                                    BuyLongList.Remove(orderDic);
                                                    LongCount--;
                                                }

                                            }
                                        }

                                    }
                                    catch (Exception e)
                                    {

                                    }
                                }
                                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));

                                    try
                                    {
                                        //사는 시점
                                        if (!DownBuyList.ContainsKey(market + interval))
                                        {
                                            if (
                                                    전전봉4 > 낮은값_72_24_전전봉
                                                    && 전봉4 < 낮은값_72_24_전봉
                                                    && 전봉8 > 낮은값_72_24_전봉
                                                    && 전봉12 > 낮은값_72_24_전봉
                                                    && 전봉4 < 전전봉4
                                                    && 전봉8 < 전전봉8
                                                    && 전봉12 < 전전봉12
                                                    && candleData_전봉.IchimokData.상한선 > 전봉4
                                            )
                                            {

                                                // 없으면 생성
                                                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);
                                                }
                                                var buyDic = new Dictionary<string, object>
                                                {
                                                    { "MarketName", market },
                                                    { "BuyDate", nowTime },
                                                    { "Price", price },
                                                    { "MCandleTimeType", (int)interval },
                                                    { "Candle", candleData }
                                                };

                                                DownBuyList.Add(market + interval, buyDic);
                                                SellShortStep.Add(market + interval, 0);

                                                if (ShortCount < 5)
                                                {
                                                    double size = YHKIM_OrderAmount / price * YHKIM_Leverage;
                                                    var orderData = FutureOrder(market, FutureMarginMode.isolated, size, price, FutureSide.BuyShort, OrderType.limit, YHKIM_Leverage);
                                                    if (orderData != null)
                                                    {
                                                        var orderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(orderData["data"]));

                                                        var orderDataDic = new Dictionary<string, object>
                                                         {
                                                            { "MarketName", market },
                                                            { "BuyDate", nowTime },
                                                            { "Price", price },
                                                            { "MCandleTimeType", (int)interval },
                                                            { "Candle", candleData },
                                                            { "Size", size },
                                                            { "orderId", orderDic["orderId"] }
                                                        };
                                                        BuyShortList.Add(orderDataDic);
                                                        ShortCount++;
                                                    }
                                                }
                                            }
                                        }
                                        //파는 시점
                                        else
                                        {
                                            var buyItem = DownBuyList[market + interval];
                                            if (interval < MCandleTimeType.H1)
                                            {
                                                var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
                                                if (nowTime < buyTime)
                                                    continue;
                                            }
                                            //임시로 처리
                                            else
                                            {
                                                var buyTime = ((DateTime)buyItem["BuyDate"]).AddMinutes((int)interval);
                                                if (nowTime < buyTime)
                                                    continue;
                                            }

                                            var compareVal = 낮은값_72_24;
                                            var val = SellShortStep[market + interval];
                                            var sellFlag = false;
                                            
                                            if (val != 101)
                                            {
                                                if (낮은값_72_24 > 현재봉8)
                                                {
                                                    SellShortStep[market + interval] = 101;
                                                    val = 101;
                                                }
                                            }

                                           if (val == 101)
                                            {
                                                compareVal = 현재봉8;
                                            }


                                            if (candleData_전봉.Close > candleData_전봉.Open &&
                                                candleData_전전봉.Close > candleData_전전봉.Open &&
                                                candleData_전전전봉.Close > candleData_전전전봉.Open)
                                                sellFlag = true;


                                            if (현재봉4 > compareVal || 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 },
                                                    { "Type", "하향"},
                                                    { "MCandleTimeType", (int)interval },
                                                    { "BuyCandle",  buyItem["Candle"] },
                                                    { "SellDate", nowTime},
                                                    { "SellPrice", price },
                                                    { "SellCandle",  candleData },
                                                    { "Rate", resultRate }
                                                };

                                                DownResultList.Add(result);
                                                DownBuyList.Remove(market + interval);
                                                SellLongStep.Remove(market + interval);
                                                var orderDic = BuyShortList.FirstOrDefault(t => t["MarketName"].ToString() == market);

                                                if (orderDic != null)
                                                {
                                                    double.TryParse(orderDic["Size"].ToString(), out var size);
                                                    var sellOrder = FutureOrder(market, FutureMarginMode.isolated, size, 0, FutureSide.SellShort, OrderType.market, YHKIM_Leverage, orderDic["orderId"].ToString());

                                                    if (sellOrder != null)
                                                    {
                                                        var sellOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(sellOrder["data"]));
                                                    }
                                                    else
                                                    {
                                                        Log.Error("Sell 안됨 확인 필요");
                                                    }


                                                    double.TryParse(orderDic["Price"].ToString(), out var buyPriceValue);
                                                    //var detail = GetFutureOrderDetail(market, sellOrderDic["orderId"]);
                                                    //var detailOrderDic = JsonConvert.DeserializeObject<Dictionary<string, string>>(JsonConvert.SerializeObject(detail["data"]));

                                                    //double.TryParse(detailOrderDic["price"].ToString(), out var sellPriceValue);

                                                    var resultRateData = ((price - buyPriceValue) / buyPriceValue) * 100;

                                                    var orderResult = new Dictionary<string, object>()
                                                    {
                                                        { "MarketName", market },
                                                        { "BuyDate", orderDic["BuyDate"]},
                                                        { "BuyPrice", orderDic["Price"] },
                                                        { "Type", "하향"},
                                                        { "MCandleTimeType", (int)interval },
                                                        { "BuyCandle",  buyItem["Candle"] },
                                                        { "SellDate", nowTime},
                                                        { "SellPrice", price },
                                                        { "SellCandle",  candleData },
                                                        { "Rate", resultRateData }
                                                    };
                                                    ResultList.Add(orderResult);
                                                    BuyShortList.Remove(orderDic);
                                                    ShortCount--;
                                                }
                                            }
                                        }
                                    }
                                    catch (Exception e)
                                    {
                                        Console.WriteLine(e.Message);
                                    }
                                }
                            }
 */