from math import nan
import pandas as pd
import plotly.graph_objects as go
from plotly import subplots
import math

import os
import json

from datetime import datetime, timedelta

from hts.BuySell_Daily import BuySell_Daily
from JSDPattern_daily import JSDPattern_daily


class Simulation_daily:

    upbit = None

    def __init__(self, RESOURCE_PATH):

        self.buySell_Daily = BuySell_Daily()
        self.jSDPattern = JSDPattern_daily(RESOURCE_PATH)

        return

    def cz(self, value):
        if value is None or math.isnan(value):
            return 0

        return value


    def clear_BSLINE(self, BUY_LIST, sell_type=None):
        if sell_type is None or sell_type == '':
            BUY_LIST['avg_buy_price'] = 0
            BUY_LIST['buy_count'] = 0
            BUY_LIST['buy_list'].clear()
        else:
            BUY_LIST['avg_buy_price'] = 0
            BUY_LIST['buy_count'] = 0

            tmp_sell_type = sell_type.split(',')
            for i, buy_list in reversed(list(enumerate(BUY_LIST['buy_list']))):
                for t_sell_type in tmp_sell_type:
                    if buy_list['buy_type'].strip() == t_sell_type.strip():
                        del BUY_LIST['buy_list'][i]
                        break
        return

    def draw(self, stock_code, data, data_scaled, bsLine=None, show=False, info=None):

        # 어제 데이터는 지운다.
        #data = data.loc[pd.DatetimeIndex(data.index).day == int(given_day[6:])]
        buy_price_line, buy_count_line, buy_type, buy_count_line, sell_price_line, sell_count_line, sell_type = [], [], [], [], [], [], []
        buy_sell_size, buy_colors, sell_colors, buy_colors = [], [], [], []

        if bsLine is not None:
            buy_price_line = bsLine['buy_price']
            buy_count_line = bsLine['buy_count']
            sell_price_line = bsLine['sell_price']
            sell_count_line = bsLine['sell_count']
            buy_type = bsLine['buy_type']
            sell_type = bsLine['sell_type']

            for i in range(len(data)):
                if buy_price_line[i] < 1:
                    buy_colors.append("#ffffff")
                    buy_price_line[i] = nan
                    buy_sell_size.append(0)
                else:
                    buy_colors.append("#0C752E")
                    buy_sell_size.append(14)
            for i in range(len(data)):
                if sell_price_line[i] < 1:
                    sell_colors.append("#ffffff")
                    sell_price_line[i] = nan
                else:
                    sell_colors.append("#00ced1")

        volume_colors = []
        for i in range(len(data)):
            if data['open'].iloc[i] > data['close'].iloc[i]:
                volume_colors.append("#FF0000")
            elif data['open'].iloc[i] < data['close'].iloc[i]:
                volume_colors.append("#FF0000")
            else:
                volume_colors.append("#000000")

        # 그래프를 설정한다.
        if bsLine is not None:
            buy_text_list, sell_text_list = [], []
            for i in range(len(data)):
                buy_text_list.append(
                    "[{}] {:,}<br>"
                    "{}, {:,} ({:,.2f})<br><br>"
                    "[BASIC]<br>"
                    "        poly_5: {:.5f}, poly_10: {:.5f}, poly_20: {:.5f}, poly_60: {:.5f}, poly_120: {:.5f}, poly_240: {:.5f}, poly_480: {:.5f}<br>"
                    "[INFO] <br>"
                    "        new_high_7: {:,.2f}, new_high_9: {:,.2f}, new_high_26: {:,.2f}, new_low_7: {:,.2f}, new_low_9: {:,.2f}, new_low_26: {:,.2f}<br>"
                    .format(data['ymd'].iloc[i].strftime('%Y-%m-%d %H:%M'), data["close"].iloc[i],
                            buy_type[i], buy_price_line[i], buy_price_line[i] * buy_count_line[i],
                            data_scaled['poly_5'].iloc[i], data_scaled['poly_10'].iloc[i], data_scaled['poly_20'].iloc[i], data_scaled['poly_60'].iloc[i], data_scaled['poly_120'].iloc[i], data_scaled['poly_240'].iloc[i], data_scaled['poly_480'].iloc[i],
                            data['new_high_7'].iloc[i], data['new_high_9'].iloc[i], data['new_high_26'].iloc[i], data['new_low_7'].iloc[i], data['new_low_9'].iloc[i], data['new_low_26'].iloc[i],
                            ))
                sell_text_list.append(
                    "[{}] {:,}<br>"
                    "{}, {:,} ({:,.2f})<br><br>"
                    "[BASIC]<br>"
                    "        poly_5: {:.5f}, poly_10: {:.5f}, poly_20: {:.5f}, poly_60: {:.5f}, poly_120: {:.5f}, poly_240: {:.5f}, poly_480: {:.5f}<br>"
                    "[INFO] <br>"
                    "        new_high_7: {:,.2f}, new_high_9: {:,.2f}, new_high_26: {:,.2f}, new_low_7: {:,.2f}, new_low_9: {:,.2f}, new_low_26: {:,.2f}<br>"
                    .format(
                        data['ymd'].iloc[i].strftime('%Y-%m-%d %H:%M'), data["close"].iloc[i],
                        sell_type[i], sell_price_line[i], sell_price_line[i] * sell_count_line[i],
                        data_scaled['poly_5'].iloc[i], data_scaled['poly_10'].iloc[i], data_scaled['poly_20'].iloc[i], data_scaled['poly_60'].iloc[i], data_scaled['poly_120'].iloc[i], data_scaled['poly_240'].iloc[i], data_scaled['poly_480'].iloc[i],
                        data['new_high_7'].iloc[i], data['new_high_9'].iloc[i], data['new_high_26'].iloc[i], data['new_low_7'].iloc[i], data['new_low_9'].iloc[i], data['new_low_26'].iloc[i],
                    ))
            buy_check = go.Scatter(x=data['ymd'], y=buy_price_line, mode='markers', name="buy_price", marker=dict(size=buy_sell_size, color=buy_colors, line_width=0), text=buy_text_list, hoverinfo="text")
            sell_check = go.Scatter(x=data['ymd'], y=sell_price_line, mode='markers', name="sell_price", marker=dict(size=14, color=sell_colors, line_width=0), text=sell_text_list, hoverinfo="text")

        volume_line = go.Bar(x=data['ymd'], y=data["volume"], marker_color=volume_colors, name='volume')

        avg5 = go.Scatter(x=data['ymd'], y=data["avg5"], name="avg5", line_color='#079118')
        avg10 = go.Scatter(x=data['ymd'], y=data["avg10"], name="avg10", line_color='grey')
        avg20 = go.Scatter(x=data['ymd'], y=data["avg20"], name="avg20", line_color='#d755e8')
        avg60 = go.Scatter(x=data['ymd'], y=data["avg60"], name="avg60", line_color='#099B92')
        avg90 = go.Scatter(x=data['ymd'], y=data["avg90"], name="avg90", line_color='#2a9c0c')
        avg120 = go.Scatter(x=data['ymd'], y=data["avg120"], name="avg120", line_color='#079118')
        avg240 = go.Scatter(x=data['ymd'], y=data["avg240"], name="avg240", line_color='#e68456')
        avg360 = go.Scatter(x=data['ymd'], y=data["avg360"], name="avg360", line_color='#e6b55c')
        avg480 = go.Scatter(x=data['ymd'], y=data["avg480"], name="avg480", line_color='#2a9c0c')
        avg720 = go.Scatter(x=data['ymd'], y=data["avg720"], name="avg720", line_color='#e75d53')
        avg1440 = go.Scatter(x=data['ymd'], y=data["avg1440"], name="avg1440", line_color='#2a9c0c')
        avg2880 = go.Scatter(x=data['ymd'], y=data["avg2880"], name="avg2880", line_color='#46406c')

        disparity_avg5 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_avg5"], name="disparity_avg5", line_color='#079118')
        disparity_avg20 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_avg20"], name="disparity_avg20", line_color='grey')
        disparity_avg60 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_avg60"], name="disparity_avg60", line_color='#d755e8')
        disparity_avg120 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_avg120"], name="disparity_avg120", line_color='#099B92')
        disparity_avg240 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_avg240"], name="disparity_avg240", line_color='#2a9c0c')
        disparity_avg480 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_avg480"], name="disparity_avg480", line_color='#079118')
        disparity_avg1440 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_avg1440"], name="disparity_avg1440", line_color='#e68456')
        disparity_480_loc = go.Scatter(x=data['ymd'], y=data_scaled["disparity_480_loc"], name="disparity_480_loc", line_color='#2a9c0c')
        disparity_1440_loc = go.Scatter(x=data['ymd'], y=data_scaled["disparity_1440_loc"], name="disparity_1440_loc", line_color='#2a9c0c')


        changeLine = go.Scatter(x=data['ymd'], y=data["changeLine"], name="changeLine", line_color='#0196ff')
        baseLine = go.Scatter(x=data['ymd'], y=data["baseLine"], name="baseLine", line_color='#991515')
        laggingSpan = go.Scatter(x=data['ymd'], y=data["laggingSpan"], name="laggingSpan", line_color='#12A524')
        leadingSpan1 = go.Scatter(x=data['ymd'], y=data["leadingSpan1"], name="leadingSpan1", line_color='#008001')
        leadingSpan2 = go.Scatter(x=data['ymd'], y=data["leadingSpan2"], name="leadingSpan2", line_color='#830fd4')

        upper_20_Line = go.Scatter(x=data['ymd'], y=data["upper_20"], name="upper_20", line_color='#0196ff')
        lower_20_Line = go.Scatter(x=data['ymd'], y=data["lower_20"], name="lower_20", line_color='#991515')
        middle_20_line = go.Scatter(x=data['ymd'], y=data["middle_20"], name="middle_20", line_color='#12A524')
        bb_pb = go.Scatter(x=data['ymd'], y=data["bb_pb"], name="bb_pb", line_color='#0196ff')
        bb_width = go.Scatter(x=data['ymd'], y=data["bb_width"], name="bb_width", line_color='#991515')

        loc_240_k = go.Scatter(x=data['ymd'], y=data["loc_240_k"], name="loc_240_k", line_color='#0196ff')
        loc_240_d = go.Scatter(x=data['ymd'], y=data["loc_240_d"], name="loc_240_d", line_color='#991515')
        loc_240_s = go.Scatter(x=data['ymd'], y=data["loc_240_s"], name="loc_240_s", line_color='#12A524')

        new_high_9 = go.Scatter(x=data['ymd'], y=data["new_high_9"], name="new_high_9", line_color='#0196ff')
        new_high_26 = go.Scatter(x=data['ymd'], y=data["new_high_26"], name="new_high_26", line_color='#991515')
        new_high_33 = go.Scatter(x=data['ymd'], y=data["new_high_33"], name="new_high_33", line_color='#12A524')
        new_high_52 = go.Scatter(x=data['ymd'], y=data["new_high_52"], name="new_high_52", line_color='#099B92')
        new_low_9 = go.Scatter(x=data['ymd'], y=data["new_low_9"], name="new_low_9", line_color='#0196ff')
        new_low_26 = go.Scatter(x=data['ymd'], y=data["new_low_26"], name="new_low_26", line_color='#991515')
        new_low_33 = go.Scatter(x=data['ymd'], y=data["new_low_33"], name="new_low_33", line_color='#12A524')
        new_low_52 = go.Scatter(x=data['ymd'], y=data["new_low_52"], name="new_low_52", line_color='#099B92')

        poly_5 = go.Scatter(x=data['ymd'], y=data_scaled["poly_5"], name="poly_5", line_color='#D27144')
        poly_10 = go.Scatter(x=data['ymd'], y=data_scaled["poly_10"], name="poly_10", line_color='#BBBEC3')
        poly_20 = go.Scatter(x=data['ymd'], y=data_scaled["poly_20"], name="poly_20", line_color='#d755e8')
        poly_60 = go.Scatter(x=data['ymd'], y=data_scaled["poly_60"], name="poly_60", line_color='#099B92')
        poly_120 = go.Scatter(x=data['ymd'], y=data_scaled["poly_120"], name="poly_120", line_color='#e68456')
        poly_240 = go.Scatter(x=data['ymd'], y=data_scaled["poly_240"], name="poly_240", line_color='#E8DD26')
        poly_480 = go.Scatter(x=data['ymd'], y=data_scaled["poly_480"], name="poly_480", line_color='#EF3644')

        disparity_diff_20_5 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_20_5"], name="disparity_diff_20_5", line_color='#D27144')
        disparity_diff_60_20 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_60_20"], name="disparity_diff_60_20", line_color='#BBBEC3')
        disparity_diff_120_20 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_120_20"], name="disparity_diff_120_20", line_color='#d755e8')
        disparity_diff_240_20 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_240_20"], name="disparity_diff_240_20", line_color='#099B92')
        disparity_diff_480_20 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_480_20"], name="disparity_diff_480_20", line_color='#e68456')
        disparity_diff_1440_20 = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_1440_20"], name="disparity_diff_1440_20", line_color='#0196ff')

        disparity_diff_20_5_rate = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_20_5_rate"], name="disparity_diff_20_5_rate", line_color='#D27144')
        disparity_diff_60_20_rate = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_60_20_rate"], name="disparity_diff_60_20_rate", line_color='#BBBEC3')
        disparity_diff_120_20_rate = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_120_20_rate"], name="disparity_diff_120_20_rate", line_color='#d755e8')
        disparity_diff_240_20_rate = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_240_20_rate"], name="disparity_diff_240_20_rate", line_color='#099B92')
        disparity_diff_480_20_rate = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_480_20_rate"], name="disparity_diff_480_20_rate", line_color='#e68456')
        disparity_diff_1440_20_rate = go.Scatter(x=data['ymd'], y=data_scaled["disparity_diff_1440_20_rate"], name="disparity_diff_1440_20_rate", line_color='#0196ff')

        slowk_up_limit = [80 for i in data['ymd']]
        slowk_middle_limit = [50 for i in data['ymd']]
        slowk_down_limit = [20 for i in data['ymd']]
        slowk_up_limit = go.Scatter(x=data['ymd'], y=slowk_up_limit, line=dict(color='grey', width=1), name='slowk_up_limit')
        slowk_middle_limit = go.Scatter(x=data['ymd'], y=slowk_middle_limit, line=dict(color='grey', width=1), name='slowk_middle_limit')
        slowk_down_limit = go.Scatter(x=data['ymd'], y=slowk_down_limit, line=dict(color='grey', width=1), name='slowk_down_limit')

        slowk_5 = go.Scatter(x=data['ymd'], y=data["slowk_5"], line=dict(color='#D27144', width=2), name='slowk_5')
        slowd_5 = go.Scatter(x=data['ymd'], y=data["slowd_5"], line=dict(dash='dashdot', color='grey', width=2), name='slowd_5')
        slowk_10 = go.Scatter(x=data['ymd'], y=data["slowk_10"], line=dict(color='#BBBEC3', width=2), name='slowk_10')
        slowd_10 = go.Scatter(x=data['ymd'], y=data["slowd_10"], line=dict(dash='dashdot', color='grey', width=2), name='slowd_10')
        slowk_20 = go.Scatter(x=data['ymd'], y=data["slowk_20"], line=dict(color='#d755e8', width=2), name='slowk_20')
        slowd_20 = go.Scatter(x=data['ymd'], y=data["slowd_20"], line=dict(dash='dashdot', color='grey', width=2), name='slowd_20')
        slowk_60 = go.Scatter(x=data['ymd'], y=data["slowk_60"], line=dict(color='#099B92', width=2), name='slowk_60')
        slowd_60 = go.Scatter(x=data['ymd'], y=data["slowd_60"], line=dict(dash='dashdot', color='grey', width=2), name='slowd_60')
        slowk_120 = go.Scatter(x=data['ymd'], y=data["slowk_120"], line=dict(color='#640745', width=2), name='slowk_120')
        slowd_120 = go.Scatter(x=data['ymd'], y=data["slowd_120"], line=dict(dash='dashdot', color='grey', width=2), name='slowd_120')
        slowk_240 = go.Scatter(x=data['ymd'], y=data["slowk_240"], line=dict(color='#e68456', width=2), name='slowk_240')
        slowd_240 = go.Scatter(x=data['ymd'], y=data["slowd_240"], line=dict(dash='dashdot', color='grey', width=2), name='slowd_240')
        slowk_480 = go.Scatter(x=data['ymd'], y=data["slowk_480"], line=dict(color='#E8DD26', width=2), name='slowk_480')
        slowd_480 = go.Scatter(x=data['ymd'], y=data["slowd_480"], line=dict(dash='dashdot', color='grey', width=2), name='slowd_480')

        min_price = go.Scatter(x=data['ymd'], y=data["min_price"], name="min_price", line_color='#0196ff')
        max_price = go.Scatter(x=data['ymd'], y=data["max_price"], name="max_price", line_color='#991515')

        text_list = []
        for i in range(len(data['ymd'])):
            text_list.append(
                "{}<br><br>"
                "       o: {}, c: {}, h: {}, l: {}<br><br>"
                "       poly_5: {:.5f}, poly_10: {:.5f}, poly_20: {:.5f}, poly_60: {:.5f}, poly_120: {:.5f}, poly_240: {:.5f}, poly_480: {:.5f}<br>"
                "       new_high_9: {}, new_high_26: {}<br>"
                "       avg5: {:.2f}, avg10: {:.2f}, avg20: {:.2f}, avg60: {:.2f}, avg90: {:.2f}, avg120: {:.2f}, avg240: {:.2f}<br>"
                "       avg360: {:.2f}, avg480: {:.2f}, avg720: {:.2f}, avg1440: {:.2f}, avg2880: {:.2f}<br><br>"
                "       loc_k: {:.2f}, loc_d: {:.2f}, loc_s: {:.2f}<br><br>"
                    .format(
                        data['ymd'].iloc[i].strftime('%Y-%m-%d %H:%M'),
                                self.cz(data["open"].iloc[i]), self.cz(data["close"].iloc[i]), self.cz(data["high"].iloc[i]), self.cz(data["low"].iloc[i]),
                                data_scaled['poly_5'].iloc[i], data_scaled['poly_10'].iloc[i], data_scaled['poly_20'].iloc[i], data_scaled['poly_60'].iloc[i], data_scaled['poly_120'].iloc[i], data_scaled['poly_240'].iloc[i], data_scaled['poly_480'].iloc[i],
                                data["new_high_9"].iloc[i], data["new_high_26"].iloc[i],
                                self.cz(data["avg5"].iloc[i]), self.cz(data["avg10"].iloc[i]), self.cz(data["avg20"].iloc[i]), self.cz(data["avg60"].iloc[i]), self.cz(data["avg90"].iloc[i]), self.cz(data["avg120"].iloc[i]), self.cz(data["avg240"].iloc[i]), self.cz(data["avg360"].iloc[i]), self.cz(data["avg480"].iloc[i]), self.cz(data["avg720"].iloc[i]), self.cz(data["avg1440"].iloc[i]), self.cz(data["avg2880"].iloc[i]),
                                self.cz(data['loc_240_k'].iloc[i]), self.cz(data['loc_240_d'].iloc[i]), self.cz(data['loc_240_s'].iloc[i]),
                            ))

        candle_stick = go.Candlestick(x=data['ymd'],
                                      open=data['open'], high=data['high'], low=data['low'], close=data['close'],
                                      increasing_line_color='red', decreasing_line_color='blue',
                                      name='candle', text=text_list, hoverinfo="text"
                                      )

        if bsLine is not None:
            candle_data = [avg5, avg10, avg20, avg60, avg90, avg120, avg240, avg360, avg480, avg720, avg1440, avg2880, min_price, max_price, buy_check, sell_check, candle_stick, changeLine, baseLine, laggingSpan, leadingSpan1, leadingSpan2, upper_20_Line, lower_20_Line, middle_20_line]
        else:
            candle_data = [avg5, avg10, avg20, avg60, avg90, avg120, avg240, avg360, avg480, avg720, avg1440, avg2880, min_price, max_price, candle_stick,changeLine, baseLine, laggingSpan, leadingSpan1, leadingSpan2]

        volume_data = [volume_line]
        disparity_data = [disparity_avg5, disparity_avg20, disparity_avg60, disparity_avg120, disparity_avg240, disparity_avg480, disparity_avg1440, disparity_480_loc, disparity_1440_loc, bb_width,
                          disparity_diff_20_5, disparity_diff_60_20, disparity_diff_120_20, disparity_diff_240_20, disparity_diff_480_20, disparity_diff_1440_20]
        loc_disparity_data = [loc_240_k, loc_240_d, loc_240_s,
                              new_high_9 ,new_high_26, new_high_33, new_high_52,new_low_9 ,new_low_26, new_low_33, new_low_52,
                              poly_5, poly_10, poly_20, poly_60, poly_120, poly_240, poly_480,
                              disparity_diff_20_5_rate, disparity_diff_60_20_rate, disparity_diff_120_20_rate, disparity_diff_240_20_rate, disparity_diff_480_20_rate, disparity_diff_1440_20_rate
                              ]
        stochastic_data = [
            slowk_up_limit, slowk_middle_limit, slowk_down_limit,
            slowk_5, slowd_5,
            slowk_10, slowd_10,
            slowk_20, slowd_20,
            slowk_60, slowd_60,
            slowk_120, slowd_120,
            slowk_240, slowd_240,
            slowk_480, slowd_480,
            bb_pb
        ]
        # 그래프를 그린다.
        """
        fig = go.Figure(data=candle_data)
        fig.update_layout(title=stock_code)
        fig.show()
        """
        fig = subplots.make_subplots(
            rows=5, cols=1,
            subplot_titles=("이격도", "이격도 위치", "slowkd", "캔들", "거래량"),
            shared_xaxes=True, horizontal_spacing=0.03, vertical_spacing=0.01,
            row_heights=[200, 200, 200, 700, 200]
        )
        for trace in disparity_data:
            fig.append_trace(trace, 1, 1)
        for trace in loc_disparity_data:
            fig.append_trace(trace, 2, 1)
        for trace in stochastic_data:
            fig.append_trace(trace, 3, 1)
        for trace in candle_data:
            fig.append_trace(trace, 4, 1)
        for trace in volume_data:
            fig.append_trace(trace, 5, 1)

        #fig.update_xaxes(nticks=5)
        #fig.update_layout(height=2400, title=stock_code, xaxis_rangeslider_visible=False)

        df = pd.DataFrame(bsLine)
        #df = df.fillna(-1)

        if info is not None:
            buy_count, sell_count = 0, 0
            if bsLine is not None:
                buy_count = len(df.loc[df["buy_price"] > 0])
                sell_count = len(df.loc[df["sell_price"] > 0])
            fig.update_layout(height=1400,
                              title="{}, buy: {} ({:,.2f}원), sell: {} ({:,.2f}원), profit: {:,.2f}원 ({:.2f}%), holding_amt: {:.2f}".format(stock_code, buy_count, info['buy_amt'], sell_count, info['sell_amt'], info['profit'], info['rate'], info['holding_amt']),
                              xaxis_rangeslider_visible=False,
                              xaxis2_rangeslider_visible=False,
                              xaxis3_rangeslider_visible=False,
                              xaxis4_rangeslider_visible=False
                              )
        else:
            buy_count = 0
            if bsLine is not None:
                buy_count = len(df.loc[df["buy_price"] > 0])
            fig.update_layout(height=1400,
                              title="{}, buy: {}번 ".format(stock_code, buy_count),
                              xaxis_rangeslider_visible=False,
                              xaxis2_rangeslider_visible=False,
                              xaxis3_rangeslider_visible=False,
                              xaxis4_rangeslider_visible=False
                              )
        #fig.update_layout(title=stock_code + "_" + str(buy_count) + "," + str(sell_count))
        # 파일로 작성함
        ###fileName = os.path.join(self.RESOURCE_PATH, 'analysis', stock_code + '.html')
        ###po.write_html(fig, file=fileName, auto_open=False)

        # 화면으로 출력함
        if show:
            fig.show()

        return


    def checkTransaction(self, ticker, data, data_scaled, ci):

        # 어제 오늘 데이터로 분석
        bsLine = {}

        if data is not None and 'close' in data.columns:
            size = len(data["close"])
            bsLine['buy_ymd'] = [None for i in range(size)]
            bsLine['buy_price'] = [0 for i in range(size)]
            bsLine['buy_count'] = [0 for i in range(size)]
            bsLine['buy_type'] = ['' for i in range(size)]
            bsLine['buy_cut'] = [None for i in range(size)]
            bsLine['sell_price'] = [0 for i in range(size)]
            bsLine['sell_count'] = [0 for i in range(size)]
            bsLine['sell_type'] = ['' for i in range(size)]
            bsLine['sell_cut'] = [0 for i in range(size)]

            size = ci
            start = 0
            for i in range(start, size):

                # 매도 확인
                sell_price, sell_count, sell_type = self.buySell_Daily.getSellPrice(ticker, data, data_scaled, i, bsLine)
                bsLine['sell_price'][i] = sell_price
                bsLine['sell_count'][i] = sell_count
                bsLine['sell_type'][i] = sell_type
                bsLine['sell_cut'][i] = 0

                if sell_price < 1:
                    buy_ymd, buy_price, buy_count, buy_type, buy_cut = self.buySell_Daily.getBuyPrice(ticker, data, data_scaled, i, bsLine)

                    bsLine['buy_ymd'][i] = buy_ymd
                    bsLine['buy_price'][i] = buy_price
                    bsLine['buy_count'][i] = buy_count
                    bsLine['buy_type'][i] = buy_type
                    bsLine['buy_cut'][i] = buy_cut

        return bsLine


    def simulate(self, ticker, get_days=720):

        data, data_scaled, ci = self.jSDPattern.getData(ticker, mins=720, ymd=ticker['ymd'], get_days=get_days)
        if data is None:
            return

        with open("config.json", "r", encoding="utf-8") as f:
            config = json.load(f)
        BUY_INFO = config['BUY_INFO']
        ticker['BUY_INFO'] = BUY_INFO
        ticker['INIT'] = True
        ticker['unit'] = self.upbit.checkUnit(data['close'].iloc[-1])
        ticker['MAX_BUY'] = self.upbit.getMaxPrice(data['close'].iloc[-1])

        bsLine = self.checkTransaction(ticker, data, data_scaled, ci)

        self.draw(ticker['ticker_code'], data, data_scaled, bsLine, show=True, info=None)

        if bsLine['buy_ymd'][ci-1] is not None:
            return True

        return False


if __name__ == "__main__":

    PROJECT_HOME = os.getcwd()
    RESOURCE_PATH = os.path.join(PROJECT_HOME, "resources")

    # 1000원 이하: 0.1
    # 1000원 이상: 1
    # 1만원 이상 10
    # 10만원 이상: 50
    # 100만원 이상: 1000
    #day_list = [(datetime.now()+timedelta(days=1)).strftime('%Y%m%d')]

    """
    all_tickers = pyupbit.get_tickers("KRW")
    tickers = []
    for ticker in all_tickers:
        #tickers.append({'ticker_code': ticker, 'ticker_name': '', 'BUY_INFO': {}, 'ymd': (datetime.now()+timedelta(days=1)).strftime('%Y%m%d')},)
        tickers.append({'ticker_code': ticker, 'ticker_name': '', 'BUY_INFO': {}, 'ymd': '20240418'},)

    TODAY_BUY_ticket_list = []
    for ticker in tickers:
        simulation = Simulation_daily(RESOURCE_PATH)
        buy = simulation.simulate(ticker, get_days=1500)
        if buy:
            TODAY_BUY_ticket_list.append(ticker)

    print ('TODAY: {}개\n{}'.format (len(TODAY_BUY_ticket_list), TODAY_BUY_ticket_list))
    
    """
    simulation = Simulation_daily(RESOURCE_PATH)
    tickers = [
        {"ticker_code": "252670", "ticker_name": "KODEX 200선물인버스2X", 'BUY_INFO': {}, 'ymd': (datetime.now()+timedelta(days=1)).strftime('%Y%m%d')},
        {"ticker_code": "122630", "ticker_name": "KODEX 레버리지", 'BUY_INFO': {}, 'ymd': (datetime.now()+timedelta(days=1)).strftime('%Y%m%d')},
        {"ticker_code": "251340", "ticker_name": "KODEX 코스닥150선물인버스", 'BUY_INFO': {}, 'ymd': (datetime.now()+timedelta(days=1)).strftime('%Y%m%d')},
        {"ticker_code": "233740", "ticker_name": "KODEX 코스닥150레버리지", 'BUY_INFO': {}, 'ymd': (datetime.now()+timedelta(days=1)).strftime('%Y%m%d')}
    ]
    for ticker in tickers:
        simulation.simulate(ticker, get_days=1500)


    print ("done...")