BitGet_API/BitgetApi/IndicatorConditionSetup/IndicatorProcess.cs

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

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

        // 스레드 시작/종료 플래그
        public bool Is_th_SignalInfo;
        public 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> 판매조건Flag = new Dictionary<string, bool>();
        public Dictionary<string, bool> 최초조건Flag = 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();

            // 추후 공통화 및 소스정리 필요
            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("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("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_전봉);


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

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

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

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

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

                                var 높은값_12_낮은값48_24 = Math.Max(candleData.movingAverageDataList[12].Value, 낮은값_48_24);
                                var 낮은값_12_높은값48_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 전전봉48 = candleData_전전봉.movingAverageDataList[48].Value;

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

                                var 현재봉4 = candleData.movingAverageDataList[4].Value;
                                var 현재봉12 = candleData.movingAverageDataList[12].Value;
                                var 현재봉24 = candleData.movingAverageDataList[24].Value;
                                var 현재봉48 = candleData.movingAverageDataList[48].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 != 60)
                                {
                                    continue;
                                }

                                #region 240분봉 처리
                                //60분봉 관련 처리
                                var candleDatas240 = findedMarket.candleDataList[MCandleTimeType.H4];
                                var candleDatas240_정렬 = candleDatas240.OrderBy(i => i.Argument).ToList();

                                var candleData240 = candleDatas240.Find(i => i.Argument == candleDatas240_정렬.Last().Argument);
                                if (candleData240 == null) continue;
                                movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas240_정렬, candleData240);
                                ichimokuConditionSetup.calIchimokuData(candleDatas240_정렬, candleData240);


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

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

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

                                var 낮은값240_48_24 = Math.Min(candleData240.movingAverageDataList[48].Value, candleData240.movingAverageDataList[24].Value);
                                var 높은값240_48_24 = Math.Max(candleData240.movingAverageDataList[48].Value, candleData240.movingAverageDataList[24].Value);

                                var 전봉낮은값240_48_24 = Math.Min(candleData240_전봉.movingAverageDataList[48].Value, candleData240_전봉.movingAverageDataList[24].Value);
                                var 전봉높은값240_48_24 = Math.Max(candleData240_전봉.movingAverageDataList[48].Value, candleData240_전봉.movingAverageDataList[24].Value);
                                var 전전봉낮은값240_48_24 = Math.Min(candleData240_전봉.movingAverageDataList[48].Value, candleData240_전봉.movingAverageDataList[24].Value);
                                var 전전봉높은값240_48_24 = Math.Max(candleData240_전봉.movingAverageDataList[48].Value, candleData240_전봉.movingAverageDataList[24].Value);

                                var 현재봉240_12 = candleData240.movingAverageDataList[12].Value;
                                var 전봉240_12 = candleData240_전봉.movingAverageDataList[12].Value;
                                var 전전봉240_12 = candleData240_전전봉.movingAverageDataList[12].Value;

                                var 현재봉240_4 = candleData240.movingAverageDataList[4].Value;
                                var 전봉240_4 = candleData240_전봉.movingAverageDataList[4].Value;
                                var 전전봉240_4 = candleData240_전전봉.movingAverageDataList[4].Value;

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

                                var 전전봉240Bol4 = candleData240_전전봉.movingAverageDataList[4].BolangerValue;
                                var 전전봉240Bol12 = candleData240_전전봉.movingAverageDataList[12].BolangerValue;
                                var 전전봉240Bol24 = candleData240_전전봉.movingAverageDataList[24].BolangerValue;
                                var 현재봉240Bol4 = candleData240.movingAverageDataList[4].BolangerValue;
                                var 현재봉240Bol12 = candleData240.movingAverageDataList[12].BolangerValue;
                                var 현재봉240Bol24 = candleData240.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} 48,24,4 상승", strInterval);
                                    var signalData = signals_SD.Find(i => i.MarketName.Equals(market) && i.Description.Equals(description));

                                    try
                                    {
                                        var candle240Flag = 현재봉240_4 < 높은값240_48_24 &&
                                            현재봉240_4 < 전봉240_4 &&
                                            현재봉240_12 < 전봉240_12 &&
                                            전봉240Bol12 - 전봉240Bol24 > 현재봉240Bol12 - 현재봉240Bol24;                                        

                                        var buyFlag = 전전봉Bol12 - 전전봉Bol24 > 전봉Bol12 - 전봉Bol24 && 전전봉Bol4 > 전봉Bol4;
                                        var sellFlag = 현재봉4 < 낮은값_12_높은값48_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);

                                        if (현재봉4 < 낮은값_48_24)
                                        {
                                            if (firstFlag)
                                                전고점Data["firstFlag"] = false;

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

                                        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 (!UpBuyList.ContainsKey(market + interval))
                                        {
                                            if (
                                                    (
                                                        전전봉4 < 높은값_48_24_전전봉 &&
                                                        전봉4 > 높은값_48_24_전봉 &&
                                                        전봉12 > 전전봉12 &&
                                                        (전봉4 < candleData_전봉.IchimokData.하한선
                                                        || 전봉4 > candleData_전봉.IchimokData.상한선) &&
                                                        전봉4 - 전전봉4 > 전봉12 - 전전봉12 &&
                                                        전봉12 - 전전봉12 > 전봉24 - 전전봉24
                                                    )
                                                && flag && !firstFlag
                                                &&
                                                buyFlag &&
                                                candle240Flag
                                                )
                                            {
                                                // 없으면 생성
                                                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);
                                                최초조건Flag[market + interval] = false;
                                                if (현재봉4 > 현재봉12)
                                                {
                                                    판매조건Flag[market + interval] = false;
                                                }
                                                else
                                                {
                                                    판매조건Flag[market + interval] = true;
                                                }
                                                if (val == 0)
                                                    전고점Data["val"] = 전봉4;

                                                전고점Data["flag"] = false;
                                                전고점Data["clearFlag"] = false;
                                            }
                                            else
                                            {
                                                if (현재봉240_12 > 전봉240_12)
                                                    최초조건Flag[market + interval] = true;
                                            }
                                        }
                                        //파는 시점
                                        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 (현재봉4 > 현재봉12 && !판매조건Flag[market + interval])
                                            {
                                                판매조건Flag[market + interval] = true;
                                            }

                                            if (!판매조건Flag[market + interval])
                                            {
                                                sellFlag = 현재봉4 < 높은값_48_24;
                                            }

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

                                    }
                                    catch (Exception e)
                                    {

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

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

                                    try
                                    {
                                        var candle240Flag = 현재봉240_4 < 높은값240_48_24 &&
                                            현재봉240_4 < 전봉240_4 &&
                                            현재봉240_12 < 전봉240_12 &&
                                            전봉240Bol12 - 전봉240Bol24 > 현재봉240Bol12 - 현재봉240Bol24;


                                        #region 3분봉 처리
                                        /*
                                        var candleDatas3 = findedMarket.candleDataList[MCandleTimeType.M3];
                                        var candleDatas3_정렬 = candleDatas3.OrderBy(i => i.Argument).ToList();

                                        var candleData3 = candleDatas3.Find(i => i.Argument == candleDatas3_정렬.Last().Argument);
                                        if (candleData3 == null) continue;
                                        movingAverageConditionSetup.Cal_YHK_Downpublic(candleDatas3_정렬, candleData3);
                                        ichimokuConditionSetup.calIchimokuData(candleDatas3_정렬, candleData3);

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

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


                                        var 높은값3_48_24 = Math.Max(candleData3.movingAverageDataList[48].Value, candleData3.movingAverageDataList[24].Value);
                                        var 낮은값3_48_24 = Math.Min(candleData3.movingAverageDataList[48].Value, candleData3.movingAverageDataList[24].Value);
                                        var 높은값3_48_24 = Math.Max(candleData3.movingAverageDataList[48].Value, candleData3.movingAverageDataList[24].Value);

                                        var 전봉낮은값3_48_24 = Math.Min(candleData3_전봉.movingAverageDataList[48].Value, candleData3_전봉.movingAverageDataList[24].Value);
                                        var 전봉높은값3_48_24 = Math.Max(candleData3_전봉.movingAverageDataList[48].Value, candleData3_전봉.movingAverageDataList[24].Value);
                                        var 전전봉낮은값3_48_24 = Math.Min(candleData3_전전봉.movingAverageDataList[48].Value, candleData3_전전봉.movingAverageDataList[24].Value);
                                        var 전전봉높은값3_48_24 = Math.Max(candleData3_전전봉.movingAverageDataList[48].Value, candleData3_전전봉.movingAverageDataList[24].Value);

                                        var 현재봉3_12 = candleData3.movingAverageDataList[12].Value;
                                        var 전봉3_12 = candleData3_전봉.movingAverageDataList[12].Value;
                                        var 전전봉3_12 = candleData3_전전봉.movingAverageDataList[12].Value;

                                        var 현재봉3_4 = candleData3.movingAverageDataList[4].Value;
                                        var 전봉3_4 = candleData3_전봉.movingAverageDataList[4].Value;
                                        var 전전봉3_4 = candleData3_전전봉.movingAverageDataList[4].Value;

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

                                        var 전전봉3Bol4 = candleData3_전전봉.movingAverageDataList[4].BolangerValue;
                                        var 전전봉3Bol12 = candleData3_전전봉.movingAverageDataList[12].BolangerValue;
                                        var 전전봉3Bol24 = candleData3_전전봉.movingAverageDataList[24].BolangerValue;
                                        var 현재봉3Bol4 = candleData3.movingAverageDataList[4].BolangerValue;
                                        var 현재봉3Bol12 = candleData3.movingAverageDataList[12].BolangerValue;
                                        var 현재봉3Bol24 = candleData3.movingAverageDataList[24].BolangerValue;

                                        //var candle3Flag = 현재봉3_4 < 낮은값3_48_24 && 전봉3_4 > 현재봉3_4 && 전전봉3_4 > 전봉3_4 && candleData3.Close < candleData3.IchimokData.상한선 && candleData3.Close < candleData3.Open;
                                        */
                                        #endregion

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

                                        //파는 시점 볼랜저 전전봉 12 - 24 값이 전봉 12 - 24보다 클경우 팜
                                        //var sellFlag = 전봉Bol12 - 전봉Bol24 < Bol12 - Bol24 || 현재봉4 > 낮은값_48_24;
                                        //var sellFlag = 현재봉4 > 낮은값_48_24 || 전전봉Bol12 - 전전봉Bol24 < 전봉Bol12 - 전봉Bol24;
                                        var sellFlag = 현재봉4 > 높은값_12_낮은값48_24;// 현재봉4 > 낮은값_48_24 || 전봉12 < 전봉4 || (전봉4 > 전전봉4 && 전봉12 > 전전봉12) || 현재봉60_4 > 전봉60_4;// || 전봉4 - 전전봉4 > 0;// || 전전봉Bol12 - 전전봉Bol24 < 전봉Bol12 - 전봉Bol24;

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

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

                                        if (현재봉4 > 높은값_48_24)
                                        {
                                            if (firstFlag)
                                                전저점Data["firstFlag"] = false;

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

                                        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 (!DownBuyList.ContainsKey(market + interval))
                                        {
                                            if (
                                                    (
                                                        전전봉4 > 낮은값_48_24_전전봉 &&
                                                        전봉4 < 낮은값_48_24_전봉 &&
                                                        //전봉24 < 전전봉24 && 
                                                        전봉12 < 전전봉12 &&
                                                        (전봉4 > candleData_전봉.IchimokData.상한선
                                                        || 전봉4 < candleData_전봉.IchimokData.하한선) &&
                                                        전봉4 - 전전봉4 < 전봉12 - 전전봉12 &&
                                                        전봉12 - 전전봉12 < 전봉24 - 전전봉24
                                                    )
                                                //||
                                                //(
                                                //    전봉4 < 전전봉4 && 전봉12 < 전전봉12 &&
                                                //    전봉24 < 전전봉24 && 전봉48 < 전전봉48 &&
                                                //    현재봉4 < 낮은값_48_24 && 현재봉12 > 현재봉4 &&
                                                //    candleData_전봉.Open > candleData_전봉.Close &&
                                                && flag && !firstFlag
                                                //)
                                                &&
                                                //최초조건Flag.ContainsKey(market + interval) && 최초조건Flag[market + interval] == true &&
                                                //볼랜저 12 24중 12가 크고 전전봉 전봉 12 차이보다 전전봉 전봉 24가 작아야함(하향)
                                                buyFlag &&
                                                candle240Flag
                                                //&&  candle3Flag
                                                )
                                            {
                                                // 없으면 생성
                                                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);
                                                최초조건Flag[market + interval] = false;
                                                if (현재봉4 > 현재봉12)
                                                {
                                                    판매조건Flag[market + interval] = false;
                                                }
                                                else
                                                {
                                                    판매조건Flag[market + interval] = true;
                                                }
                                                if (val == 0)
                                                    전저점Data["val"] = 전봉4;

                                                전저점Data["flag"] = false;
                                                전저점Data["clearFlag"] = false;
                                            }
                                            else
                                            {
                                                if (현재봉240_12 > 전봉240_12)
                                                    최초조건Flag[market + interval] = true;
                                            }
                                        }
                                        //파는 시점
                                        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 (현재봉4 < 현재봉12 && !판매조건Flag[market + interval])
                                            {
                                                판매조건Flag[market + interval] = true;
                                            }

                                            if (!판매조건Flag[market + interval])
                                            {
                                                sellFlag = 현재봉4 > 낮은값_48_24;
                                            }

                                            if (sellFlag)
                                            {

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

                                                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);
                                            }
                                        }
                                    }
                                    catch (Exception e)
                                    {

                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception e)
                {

                }
            }
        }


        public void calIchimokuProcess_Add()
        {


        }

        public void calIchimokuProcess_Update()
        {

        }
    }
}