import datetime
from sqlalchemy import *
from sqlalchemy import event
import pymysql
from pandas import *

from library.Logger import *
import library.cf
from library.open_api import *

class simulator_api:
    def __init__(self,simul_num,op,db_name):
        self.cf=library.cf
        self.simul_num=int(simul_num)

        if self.simul_num==-1:
            self.date_setting()

        elif op=='reset':
            self.op='reset'
            self.simul_reset=True
            self.variable_setting()
            self.rotate_date()

        elif op=='real':
            self.op='real'
            self.simul_reset=False
            self.db_name=db_name
            self.variable_setting()

        elif op=='continue':
            self.op='continue'
            self.simul_reset=False
            self.variable_setting()
            self.rotate_date()

        else:
            logger.error("Invalid simulator number/simulator option")

    # 오늘 날짜를 설정하는 함수
    def date_setting(self):
        self.today=datetime.datetime.today().strftime("%Y%m%d")
        self.today_detail=datetime.datetime.today().strftime("%Y%m%d%H%M")
        self.today_date_form=datetime.datetime.strptime(self.today,"%Y%m%d").date()

    # 사용되는 변수를 설정하는 함수
    def variable_setting(self):
        self.date_setting()
        self.simul_end_date=self.today          # 시뮬레이션이 끝나는 날짜
        self.start_min="0900"                   # 장 시작 시간 : 9시

        self.use_min=False                      # 분별 시뮬레이션을 사용하는 변수
        self.only_nine_buy=True                 # 9시에만 거래를 수행하는 변수
        self.buy_stop=False                     # 거래를 중지하는 변수
        self.trade_check_num=False              # 실시간 조건 매수 옵션. 분별 시뮬레이팅의 경우 True, 일별 시뮬레이팅의 경우 False

        self.use_ai=False                       # ai(deep learning) 알고리즘 사용 여부
        self.ai_num=1                           # ai 알고리즘 번호

        print("simul_num : ",self.simul_num)

        self.volume_limit=1000

        if self.simul_num==1:
            self.simul_start_date="20190101"

            self.db_to_realtime_daily_buy_list_num=1    # 매수리스트 설정 알고리즘
            self.sell_list_num=1                        # 매도리스트 설정 알고리즘

            # 시뮬레이션 변수 설정
            self.start_invest_price=1000000     # 초기 투자자금
            self.invest_unit=100000             # 매수 금액 단위
            self.limit_money=300000             # 자산 중 최소로 남겨 둘 금액
            self.sell_point=10                  # 익절 수익률 기준
            self.losscut_point=-2               # 손절 수익률 기준

            self.invest_limit_rate=1.01         # 매수하는 순간 종목의 최신 종가보다 가격이 n%이상 상승했을 때는 매수하지 않음
            self.invest_min_limit_rate=0.98     # 매수하는 순간 종목의 최신 종가보다 가격이 n%이상 하락했을 경우 매수하지 않음

        elif self.simul_num==2:
            self.simul_start_date="20190101"

            self.db_to_realtime_daily_buy_list_num=2
            self.sell_list_num=2

            self.start_invest_price=1000000
            self.invest_unit=100000
            self.limit_money=300000
            self.sell_point=10
            self.losscut_point=-2

            self.invest_limit_rate=1.01
            self.invest_min_limit_rate=0.98

        elif self.simul_num==3:
            self.simul_start_date = "20190101"

            self.db_to_realtime_daily_buy_list_num = 3
            self.sell_list_num = 3

            self.start_invest_price = 1000000
            self.invest_unit = 100000
            self.limit_money = 300000
            self.sell_point = 10
            self.losscut_point = -2

            self.invest_limit_rate = 1.01
            self.invest_min_limit_rate = 0.98

        else:
            logger.error("Invalid simul_num")

        self.db_name_setting()

        if self.op!='real':
            # database, table 초기화
            self.table_setting()
            # 시뮬레이팅 할 날짜 저장
            self.get_date_for_simul()

            self.total_valuation_profit=0                       # 매도 종목들에 대한 총 수익
            self.sum_valuation_profit=0                         # 실제 수익 = 매도종목에 대한 수익 + 현재 보유 종목의 수익
            self.total_invest_price=self.start_invest_price     # 총자산 : 투자금액 + 실제 수익
            self.total_purchase_price=0                         # 투자금
            self.d2_deposit=self.start_invest_price             # 예수금 = 초기자본 + 매도수익 - 투자금

            # 일별 정산
            self.check_balance()

            self.tax_rate=0.0025                                # 거래 세금
            self.fees_rate=0.00015                              # 거래 수수료

            self.simul_reset_lock=False                         # 시뮬레이터를 멈춘 지점부터 다시 돌릴 것인지를 선택하는 변수

    # database를 control하기 위한 engine 및 connection을 저장하는 함수
    def db_name_setting(self):
        # simul database에 접속하는 engine
        if self.op=='real':
            self.engine_simul=create_engine("mysql+pymysql://" + self.cf.db_id + ":" + self.cf.db_pw + "@" + self.cf.db_ip + ":" +
                                            self.cf.db_port + "/" + str(self.db_name), encoding='utf-8')
        else:
            self.db_name="simul"+str(self.simul_num)
            self.engine_simul=create_engine("mysql+pymysql://" + self.cf.db_id + ":" + self.cf.db_pw + "@" + self.cf.db_ip + ":" +
                                            self.cf.db_port + "/" + str(self.db_name), encoding='utf-8')
        # daily_craw database에 접속하는 engine
        # daily_craw        :   각 종목에 대해 날짜별 데이터를 저장하는 데이터베이스
        self.engine_daily_craw = create_engine("mysql+pymysql://" + self.cf.db_id + ":" + self.cf.db_pw + "@" + self.cf.db_ip + ":" +
                                               self.cf.db_port + "/daily_craw" , encoding='utf-8')
        # min_craw database에 접속하는 engine
        # min_craw          :   각 종목에 대해 분별 데이터를 저장하는 데디터베이스
        self.engine_craw = create_engine("mysql+pymysql://" + self.cf.db_id + ":" + self.cf.db_pw + "@" + self.cf.db_ip + ":" +
                                          self.cf.db_port + "/min_craw", encoding='utf-8')
        # daily_buy_list database에 접속하는 engine
        # daily_buy_list    :   날짜별로 종목에 대한 데이터를 저장하는 데이터베이스
        self.engine_daily_buy_list = create_engine("mysql+pymysql://" + self.cf.db_id + ":" + self.cf.db_pw + "@" + self.cf.db_ip + ":" +
                                          self.cf.db_port + "/daily_buy_list", encoding='utf-8')

        from library.open_api import escape_percentage
        event.listen(self.engine_simul, 'before_execute', escape_percentage, retval=True)
        event.listen(self.engine_daily_craw, 'before_execute', escape_percentage, retval=True)
        event.listen(self.engine_craw, 'before_execute', escape_percentage, retval=True)
        event.listen(self.engine_daily_buy_list, 'before_execute', escape_percentage, retval=True)

        # mysql에 접속하는 객체 생성
        self.db_conn = pymysql.connect(
            host=self.cf.db_ip,
            port=int(self.cf.db_port),
            user=self.cf.db_id,
            password=self.cf.db_pw,
            charset='utf8'
        )

    # 데이터베이스와 테이블을 설정
    def table_setting(self):
        # simul_reset==True인 경우, 시뮬레이터를 초기화하고 다시 구축
        if self.simul_reset:
            self.init_database()

        # simul_reset==False인 경우, 시뮬레이터를 초기화하지 않고 마지막으로 끝난 시점 부터 다시 구동
        else:
            # 시뮬레이터 데이터베이스, transaction 테이블, account_balance 테이블이 모두 존재하는 경우 이어서 시뮬레이션
            if (self.is_simul_database_exist() and
                    self.is_simul_table_exist(self.db_name,"all_stocks") and
                    self.is_simul_table_exist(self.db_name,"jango_data")):
                self.init_df_jango()
                self.init_df_all_stocks()
                self.last_simul_date=self.get_jango_data_last_date()
            # 필요한 데이터베이스와 테이블이 모두 존재하지 않는 경우, 다시 생성
            else:
                self.init_database()
                self.simul_reset=True

    # 시뮬레이터 데이터베이스 초기화
    def init_database(self):
        self.drop_database()
        self.create_database()
        self.init_df_jango()            # 잔고 내역 테이블
        self.init_df_all_stocks()       # 모든 거래 내역을 저장하는 테이블

    # 시뮬레이터 데이터베이스 삭제
    def drop_database(self):
        if self.is_simul_database_exist():
            query=f"drop DATABASE {self.db_name}"
            self.db_conn.cursor().execute(query)
            self.db_conn.commit()

    # 시뮬레이터 데이터베이스 생성
    def create_database(self):
        if not self.is_simul_database_exist():
            query=f"create DATABASE {self.db_name}"
            self.db_conn.cursor().execute(query)
            self.db_conn.commit()

    # 시뮬레이터 데이터베이스가 존재하는지 확인하는 함수
    def is_simul_database_exist(self):
        query = f"SELECT 1 FROM Information_schema.SCHEMATA WHERE SCHEMA_NAME = '{self.db_name}'"
        result=self.engine_daily_buy_list.execute(query).fetchall()
        if len(result):
            return True
        else:
            return False

    # 시뮬레이터 데이터베이스 안에 특정 이름을 가진 테이블이 존재하는지 확인하는 함수
    def is_simul_table_exist(self,db_name,table_name):
        query = f"select 1 from information_schema.tables where table_schema = '{db_name}' and table_name = '{table_name}'"
        result=self.engine_simul.execute(query).fetchall()
        if len(result)==1:
            return True
        else:
            return False

    # jango table 생성    :   잔고 내역을 저장하는 테이블
    def init_df_jango(self):
        jango_temp={'id':[]}
        self.jango=DataFrame(jango_temp,
                             columns=['date', 'today_earning_rate', 'sum_valuation_profit', 'total_profit',
                                      'today_profit','today_profitcut_count', 'today_losscut_count',
                                      'today_profitcut','today_losscut','d2_deposit', 'total_possess_count',
                                      'today_buy_count', 'today_buy_list_count', 'total_invest',
                                      'sum_item_total_purchase', 'total_evaluation', 'today_rate',
                                      'today_invest_price','today_sell_price', 'volume_limit', 'sell_point',
                                      'invest_limit_rate','invest_unit','limit_money', 'total_profitcut',
                                      'total_losscut','total_profitcut_count','total_losscut_count',
                                      'today_buy_today_sell_count','today_buy_today_possess_count',
                                      'today_buy_today_profitcut_count','today_buy_today_losscut_count',
                                      'today_buy_today_profitcut_rate','today_buy_today_losscut_rate'],
                             index=jango_temp['id'])

    # all_stocks table 생성   :   모든 거래내역을 저장하는 테이블
    def init_df_all_stocks(self):
        all_stocks_temp={'id':[]}
        self.df_all_stocks=DataFrame(all_stocks_temp,
                                     columns=['id', 'order_num', 'code', 'code_name', 'rate', 'purchase_rate',
                                              'purchase_price','present_price', 'valuation_price','valuation_profit',
                                              'holding_amount', 'buy_date', 'item_total_purchase','chegyul_check',
                                              'invest_unit','sell_date', 'sell_price', 'sell_rate',
                                              'yes_close','d1_diff_rate', 'd1_diff',
                                              'open', 'close','high','low','volume',
                                              'clo5', 'clo10', 'clo20', 'clo60','clo120',
                                              "clo5_diff_rate", "clo10_diff_rate","clo20_diff_rate",
                                              "clo60_diff_rate", "clo120_diff_rate"])

    #jango(잔고 테이블)에 저장된 가장 최근의 날짜를 가져오는 함수
    def get_jango_data_last_date(self):
        query = "SELECT date from jango_data order by date desc limit 1"
        result=self.engine_simul.execute(query).fechall()
        return result[0][0]

    # 시뮬레이팅 할 날짜 리스트를 가져오는 함수
    # 장이 열렸던 날을 self.date_rows에 담기 위해 gs글로벌의 date값을 이용
    def get_date_for_simul(self):
        query = f"select date from `대한항공` " \
                f"where date >= '{self.simul_start_date}' and date <= '{self.simul_end_date}' group by date"
        self.date_rows = self.engine_daily_craw.execute(query).fetchall()

    # 거래한 데이터를 바탕으로 거래이력(all_stocks) 테이블을 정산하는 함수
    def check_balance(self):
        # all_stocks table이 존재하지 않을 경우 return
        if not self.is_simul_table_exist(self.db_name,"all_stocks"):
            return

        query="select sum(valuation_profit) from all_stocks"
        self.sum_valuation_profit=self.engine_simul.execute(query).fetchall()[0][0]     # 총수익금 (종목별 평가 금액의 합)

        self.total_invest_price=self.start_invest_price+self.sum_valuation_profit       # 총자산

        query="select sum(item_total_purchase) from all_stocks where sell_date='%s'"
        self.total_purchase_price=self.engine_simul.execute(query%(0)).fetchall()[0][0] # 총투자금액
        if self.total_purchase_price is None:
            self.total_purchase_price=0

        query="select sum(valuation_profit) from all_stocks where sell_date!='%s'"
        self.total_valuation_profit=self.engine_simul.execute(query%(0)).fetchall()[0][0]   # 매도 종목들에 대한 수익
        if self.total_valuation_profit is None:
            self.total_valuation_profit=0

        self.d2_deposit=self.start_invest_price+self.total_valuation_profit-self.total_purchase_price   # 투자가능 예수금

    # 날짜별로 돌아가면서 시뮬레이션을 실행하는 함수
    def rotate_date(self):
        for i in range(1,len(self.date_rows)):
            date_rows_today=self.date_rows[i][0]        # 시뮬레이팅 할 날짜
            date_rows_yesterday=self.date_rows[i-1][0]  # 시뮬레이팅 하루 전 날짜

            # simul_reset=False인 경우, 시뮬레이터를 멈춘 지점부터 다시 시작
            if not self.simul_reset and not self.simul_reset_lock:
                if int(date_rows_today)<=int(self.last_simul_date):
                    continue
                else:
                    self.simul_reset_lock=True

            # 분별 시뮬레이션
            if self.use_min:
                self.simul_by_min(date_rows_today,date_rows_yesterday,i)
            # 일별 시뮬레이션
            else:
                self.simul_by_date(date_rows_today,date_rows_yesterday,i)
        # 시뮬레이션을 완료한 후 jango_data 테이블 업데이트
        self.arrange_jango_data()

    # 하루에 대한 시뮬레이션이 끝난 뒤 해당 날짜의 잔고(jango_data)정보를 업데이트하는 함수
    def arrange_jango_data(self):
        if self.engine_simul.dialect.has_table(self.engine_simul,"jango_data"):
            len_date=self.get_len_jango_data_date()
            query="select date from jango_data"
            rows=self.engine_simul.execute(query).fetchall()

            logger.debug("account balance 최종 정산")

            for i in range(len_date):
                # today_buy_count : 오늘 매수한 종목의 수
                query="update jango_data " \
                      "set " \
                      "today_buy_count=(select count(*) from (select code from all_stocks where buy_date like '%s')) "\
                      "where date='%s'"
                self.engine_simul.execute(query%("%%"+str(rows[i][0])+"%%",rows[i][0]))

                # today_buy_today_sell_count : 오늘 매수하고 오늘 매도한 종목의 수
                query="update jango_data " \
                      "set " \
                      "today_buy_today_sell_count=" \
                      "(select count(*) from " \
                      "(select code from all_stocks where buy_date like '%s' and sell_date!=0 group by code)) " \
                      "where date='%s'"
                self.engine_simul.execute(query%("%%"+str(rows[i][0])+"%%",rows[i][0]))

                # today_buy_today_possess_count : 오늘 매수하였으나 매도하지 않은 종목의 수
                query="update jango_data " \
                      "set" \
                      "today_buy_today_possess_count=" \
                      "(select count(*) from " \
                      "(select code from all_stocks where buy_date like '%s' and sell_date='%s' group by code)) " \
                      "where date='%s'"
                self.engine_simul.execute(query%("%%"+rows[i][0]+"%%",0,rows[i][0]))

                # today_buy_today_profitcut_count : 오늘 매수하고 익절한 종목의 수
                query="update jango_data " \
                      "set " \
                      "today_buy_today_profitcut_count=" \
                      "(select count(*) from " \
                      "(select code from all_stocks " \
                      "where buy_date like '%s' and sell_date like '%s' and sell_rate>'%s' group by code)) " \
                      "where date='%s'"
                self.engine_simul.execute(query%("%%" + rows[i][0] + "%%", "%%" + rows[i][0] + "%%", 0, rows[i][0]))

                # today_buy_today_profitcut_rate : 오늘 매수하고 익절한 종목의 수익률
                query = "update jango_data " \
                        "set " \
                        "today_buy_today_profitcut_rate=round(today_buy_today_profitcut_count /today_buy_count *100,2) "\
                        "where date = '%s'"
                self.engine_simul.execute(query%(rows[i][0]))

                # today_buy_today_losscut_count : 오늘 매수하고 손절한 종목의 수
                query = "update jango_data " \
                        "set " \
                        "today_buy_today_losscut_count=" \
                        "(select count(*) from " \
                        "(select code from all_stocks " \
                        "where buy_date like '%s' and sell_date like '%s' and sell_rate < '%s' group by code)) " \
                        "WHERE date='%s'"
                self.engine_simul.execute(query%("%%" + rows[i][0] + "%%", "%%" + rows[i][0] + "%%", 0, rows[i][0]))

                # today_buy_today_losscut_rate : 오늘 매수하고 손절한 종목의 수익률
                query = "update jango_data " \
                        "set " \
                        "today_buy_today_losscut_rate=round(today_buy_today_losscut_count /today_buy_count *100,2) " \
                        "WHERE date = '%s'"
                self.engine_simul.execute(query%(rows[i][0]))

                # total_profitcut_count : 총 익절한 종목의 수
                query = "update jango_data " \
                        "set " \
                        "total_profitcut_count=" \
                        "(select count(*) from " \
                        "(select code from all_stocks where sell_rate >= '%s'  group by code)) "\
                        "WHERE date='%s'"
                self.engine_simul.execute(query%(0, rows[i][0]))

                # total_profitcut : 총 익절한 금액 (매도가 - 매수가)
                query = "update jango " \
                        "set " \
                        "total_profitcut=sum" \
                        "(select sell_price-purchase_price from all_stocks " \
                        "where sell_price>=purchase_price group by code))" \
                        "WHERE date = '%s'"
                self.engine_simul.execute(query%(rows[i][0]))

                # total_losscut_count : 총 손절한 종목의 수
                query = "update jango_data " \
                        "set " \
                        "total_losscut_count=" \
                        "(select count(*) from " \
                        "(select code from all_stocks where sell_rate < '%s'  group by code )) " \
                        "WHERE date='%s'"
                self.engine_simul.execute(query%(0,rows[i][0]))

                # total_losscut : 총 손절한 금액 (매수가 - 매도가)
                query = "update jango_data " \
                        "set " \
                        "total_losscut=sum" \
                        "(select purchase_price-sell_price from all_stocks " \
                        "where purchase_price>=sell_price)) " \
                        "where date='%s'"
                self.engine_simul.execute(query%(rows[i][0]))
        print("account balance 정산 완료")

    # jango_data에 저장된 일자를 반환하는 함수
    def get_len_jango_data_date(self):
        query="select date from jango_data"
        rows=self.engine_simul.execute(query).fetchall()
        return len(rows)

    # 분별 시뮬레이팅
    def simul_by_min(self, date_rows_today, date_rows_yesterday, i):
        print("**************************   date: " + date_rows_today)
        # 시뮬레이팅 전에 변수 초기화
        self.daily_variable_setting()
        # daily_buy_list에 시뮬레이팅 할 날짜에 해당하는 테이블과 전 날 테이블이 존재하는지 확인
        if self.is_date_exist(date_rows_today) and self.is_date_exist(date_rows_yesterday):
            self.db_to_realtime_daily_buy_list(date_rows_today, date_rows_yesterday, i)     # 매수리스트 확인
            self.trading_by_min(date_rows_today, date_rows_yesterday, i)                    # 시뮬레이팅 시작

            # all_stocks 테이블이 존재하고, 현재 보유 중인 종목이 있는 경우, 해당 종목에 대해 데이터베이스 업데이트
            if self.is_simul_table_exist(self.db_name, "all_stocks") and len(self.get_data_from_possessed_item()) != 0:
                self.update_all_db_by_date(date_rows_today, option='ALL')

            self.db_to_jango(date_rows_today)  # 정산
        else:
            print("테이블이 존재하지 않습니다")

    # 매일 시뮬레이션이 돌기 전에 변수를 초기화하는 함수
    def daily_variable_setting(self):
        self.buy_stop=False
        self.today_invest_price=0

    # daily_buy_list에 특정 날짜의 이름을 가진 테이블이 존재하는지 확인하는 함수
    def is_date_exist(self,date):
        query = f"select 1 from information_schema.tables where table_schema ='daily_buy_list' and table_name ='{date}'"
        result = self.engine_daily_buy_list.execute(query).fetchall()
        if len(result) == 1:
            return True
        else:
            return False

    # 다음날 매수 할 종목의 리스트를 선정하는 함수
    def db_to_realtime_daily_buy_list(self,date_rows_today,date_rows_yesterday,i):
        realtime_daily_buy_list=None            # 다음날 매수할 종목 리스트를 저장하는 변수
        # (5,20) 골든크로스
        if self.db_to_realtime_daily_buy_list_num == 1:
            query=f"select * from `{date_rows_yesterday}` " \
                  f"where yes_clo20>yes_clo5 and clo5>clo20 and close<'{self.invest_unit}' group by code"
            realtime_daily_buy_list=self.engine_daily_buy_list.execute(query).fetchall()

        # (20,60) 골든크로스
        elif self.db_to_realtime_daily_buy_list_num == 2:
            query = f"select * from `{date_rows_yesterday}` " \
                    f"where yes_clo40 > yes_clo5 and clo5 > clo40 and close < '{self.invest_unit}' group by code"
            realtime_daily_buy_list = self.engine_daily_buy_list.execute(query).fetchall()

        else:
            logger.error("Invalid Algorithm Setting...")

        # 알고리즘에 의해 선택된 항목이 존재한다면 데이터베이스에 해당 항목 업데이트
        if len(realtime_daily_buy_list) > 0:
            df_realtime_daily_buy_list = DataFrame(realtime_daily_buy_list,
                                                   columns=['index', 'index2', 'date', 'check_item', 'code',
                                                            'code_name', 'd1_diff','d1_diff_rate',
                                                            'close', 'open', 'high','low', 'volume',
                                                            'clo5', 'clo10', 'clo20', 'clo60', 'clo120',
                                                            "clo5_diff_rate", "clo10_diff_rate", "clo20_diff_rate",
                                                            "clo60_diff_rate", "clo120_diff_rate",
                                                            'yes_clo5', 'yes_clo10', 'yes_clo20', 'yes_clo60','yes_clo120',
                                                            'vol5', 'vol10', 'vol20', 'vol60', 'vol120'])

            # 다음날 매수할 종목 중 code가 6자리의 정수로 된 항목만 선택
            df_realtime_daily_buy_list['code'] = df_realtime_daily_buy_list['code'].apply(
                lambda x: "{:0>6d}".format(int(x)))

            # 시뮬레이터
            if self.op != 'real':
                df_realtime_daily_buy_list['check_item'] = int(0)
                df_realtime_daily_buy_list.to_sql('realtime_daily_buy_list', self.engine_simul, if_exists='replace')

                # 현재 보유 중인 종목은 매수 리스트(realtime_daily_buy_list) 에서 제거
                if self.is_simul_table_exist(self.db_name, "all_stocks"):
                    query = "delete from realtime_daily_buy_list " \
                            "where code in " \
                            "(select code from all_stocks where sell_date = '0')"
                    self.engine_simul.execute(query)

                # realtime_daily_buy_list 테이블에 저장 된 종목들을 저장
                self.get_realtime_daily_buy_list()

            # 모의투자 / 실전투자
            else:
                df_realtime_daily_buy_list['check_item'] = int(0)
                df_realtime_daily_buy_list.to_sql('realtime_daily_buy_list', self.engine_simul, if_exists='replace')

                # 현재 보유 중인 종목들은 삭제
                query = "delete from realtime_daily_buy_list where code in (select code from possessed_item)"
                self.engine_simul.execute(query)
        else:
            self.len_df_realtime_daily_buy_list = 0

    # realtime_daily_buy_list 테이블의 매수 리스트를 가져오는 함수
    def get_realtime_daily_buy_list(self):
        # check_item = 매수 했을 시 날짜. 매수 하지 않았을 때는 0
        query = "select * from realtime_daily_buy_list where check_item = '0' group by code"
        realtime_daily_buy_list=self.engine_simul.execute(query).fetchall()

        self.df_realtime_daily_buy_list=DataFrame(realtime_daily_buy_list,
                                                  columns=['index', 'index2', 'index3','date', 'check_item', 'code',
                                                           'code_name', 'd1_diff','d1_diff_rate',
                                                           'close', 'open', 'high','low', 'volume',
                                                           'clo5', 'clo10', 'clo20', 'clo60', 'clo120',
                                                           "clo5_diff_rate", "clo10_diff_rate", "clo20_diff_rate",
                                                           "clo60_diff_rate", "clo120_diff_rate",
                                                           'yes_clo5', 'yes_clo10', 'yes_clo20', 'yes_clo60','yes_clo120',
                                                           'vol5', 'vol10', 'vol20', 'vol60', 'vol120'])

        self.len_df_realtime_daily_buy_list = len(self.df_realtime_daily_buy_list)

    # 분별 시뮬레이팅 함수
    # 기능 : 새로운 종목 매수 / 보유종목 매도 / 보유종목 업데이트
    def trading_by_min(self,date_rows_today,date_rows_yesterday,i):
        self.show_info(date_rows_today)

        # 현재 보유중인 종목이 존재한다면, 보유 종목의 주가를 업데이트
        if self.is_simul_table_exist(self.db_name,"all_stocks"):
            self.update_all_db_by_date(date_rows_today,option='OPEN')

        # 분별 시간 데이터를 가져오기
        self.get_date_min_for_simul(date_rows_today)
        if len(self.min_date_rows)!=0:
            # 분 단위로 시뮬레이팅
            for t in range(len(self.min_date_rows)):
                min=self.min_date_rows[t][0]
                # 현재 보유 종목이 있는 경우
                if self.is_simul_table_exist(self.db_name,"all_stocks") and len(self.get_data_from_possessed_item())!=0:
                    self.show_info(min)
                    # 종목 데이터 업데이트
                    self.update_all_db_by_min(min)
                    self.update_all_db_etc()
                    # 매도
                    self.auto_trade_sell_stock(min,i)

                    # 매수를 진행할 금액이 남아있는 경우
                    if not self.buy_stop and self.jango_check():
                        # 매수할 종목리스트 저장
                        self.get_realtime_daily_buy_list()
                        # 매수할 종목이 존재한다면 매수
                        if self.len_df_realtime_daily_buy_list>0:
                            self.auto_trade_stock_realtime(min,date_rows_today,date_rows_yesterday)
                        else:
                            print("금일 매수할 종목이 없습니다")
                # 보유 종목이 없는 경우
                else:
                    if not self.buy_stop and self.jango_check():
                        self.auto_trade_stock_realtime(min,date_rows_today,date_rows_yesterday)

                if not self.buy_stop and self.only_nine_buy:
                    print("9시 매수를 종료합니다")
                    self.buy_stop=True

    # 시뮬레이팅 정보를 출력하는 함수
    def show_info(self,date):
        print("simulator num : ",self.simul_num)
        if self.is_simul_table_exist(self.db_name,"all_stocks"):
            print("simulating 시간 : ",date)
            print("보유종목 수 : ",self.get_count_possess_item())

    # 현재 보유하고 있는 종목수를 반환하는 함수
    def get_count_possess_item(self):
        query="select count(*) from all_stocks where sell_date='0'"
        result=self.engine_simul.execute(query).fetchall()
        return result[0][0]

    # 보유 종목의 주가를 일별로 업데이트하는 함수
    def update_all_db_by_date(self,date,option='ALL'):
        possessed_item_list=self.get_data_from_possessed_item()

        if len(possessed_item_list)==0:
            print("보유 종목이 없습니다")

        for i in range(len(possessed_item_list)):
            code_name=possessed_item_list[i][0]
            result=self.get_now_price_by_date(code_name,date)
            if result==False:
                continue

            d1_diff=result[0][0]
            d1_diff_rate = result[0][1]
            close = result[0][2]
            open = result[0][3]
            high = result[0][4]
            low = result[0][5]
            volume = result[0][6]
            clo5 = result[0][7]
            clo10 = result[0][8]
            clo20 = result[0][9]
            clo60 = result[0][10]
            clo120 = result[0][11]

            if open:
                self.db_to_all_stocks_present_price_update(code_name,d1_diff,d1_diff_rate,close,open,high,low,volume,
                                                          clo5,clo10,clo20,clo60,clo120,option)
            else:
                continue

    # 보유한 종목의 이름을 반환하는 함수
    def get_data_from_possessed_item(self):
        query="select code_name from all_stocks where sell_date='0'"
        return self.engine_simul.execute(query).fetchall()

    # daily_buy_list를 통해 특정 날짜에 해당하는 주가정보를 가져오는 함수
    def get_now_price_by_date(self,code_name,date):
        print(code_name)
        query = f"select d1_diff,d1_diff_rate, close, open, high, low, volume, clo5, clo10, clo20, clo60, clo120 " \
                f"from `{date}` " \
                f"where code_name = '{code_name}' group by code"
        result=self.engine_daily_buy_list.execute(query).fetchall()

        if len(result)==1:
            return result
        else:
            return False

    # 현재의 주가를 거래이력(all_stocks)에 있는 보유 종목에 반영
    def db_to_all_stocks_present_price_update(self,code_name,d1_diff,d1_diff_rate,close,open,high,low,volume,
                                              clo5,clo10,clo20,clo60,clo120,option='ALL'):
        # 모의투자 / 실전투자의 경우 현재가를 종가로 업데이트
        if self.op=='real':
            present_price=close
        # 시뮬레이터의 경우 현재가를 시가로 업데이트
        else:
            present_price=open

        # option==ALL이면 모든 데이터를 업데이트
        if option=="ALL":
            query = f"update all_stocks " \
                    f"set " \
                    f"d1_diff={d1_diff}, d1_diff_rate = {d1_diff_rate}, " \
                    f"close = {close}, open = {open}, high = {high}, low = {low}, volume = {volume}, " \
                    f"present_price = {present_price}, " \
                    f"clo5 = {clo5}, clo10 = {clo10}, clo20 = {clo20}, clo60 = {clo60}, clo120 = {clo120} " \
                    f"where code_name = '{code_name}' and sell_date = '{0}'"
        # option==open이면 open,present_price값만 업데이트
        else:
            query = f"update all_stocks " \
                    f"set " \
                    f"open = {open}, present_price = {present_price} " \
                    f"where code_name = '{code_name}' and sell_date = '{0}'"

        self.engine_simul.execute(query)

    # 분 데이터를 가져오는 함수
    def get_date_min_for_simul(self,simul_start_date):
        simul_start_date_min=simul_start_date+self.start_min    # 장 시작시간 = 9시
        simul_end_date_min=simul_start_date+"1530"              # 장 마감시간 = 3시 30분

        query = f"select date from `대한항공` " \
                f"where date >= '{simul_start_date_min}' and date <='{simul_end_date_min}' and open != 0 group by date"
        self.min_date_rows = self.engine_craw.execute(query).fetchall()

    # 거래이력(all_stocks)의 시세(close) 데이터를 분 별로 업데이트
    def update_all_db_by_min(self,min):
        possessed_code_name=self.get_data_from_possessed_item()
        for i in range(len(possessed_code_name)):
            code_name=possessed_code_name[i][0]
            current_close_price=self.get_now_close_price_by_min(code_name,min)
            if current_close_price:
                self.db_to_all_stocks_present_price_update_by_min(code_name,current_close_price)
            else:
                continue

    # 분별 현재 종가(close)를 가져오는 함수
    # 분별 데이터에서 종가는 현재가를 의미하므로 1분마다 시세를 가져오는 함수
    def get_now_close_price_by_min(self,code_name,min):
        query=f"select close from `{code_name}` " \
              f"where date='{min}' and open!=0 and volume!=0 order by sum_volume desc limit 1"
        result=self.engine_craw.execute(query).fethcall()
        if len(result)==1:
            return result[0][0]
        else:
            return False

    # 보유한 종목에 현재가를 실시간으로 업데이트하는 함수
    def db_to_all_stocks_present_price_update_by_min(self,code_name,current_close_price):
        query=f"update all_stocks set present_price='{current_close_price}' " \
              f"where code_name={code_name} and sell_date='{0}'"
        self.engine_simul.execute(query)

    # 보유중인 종목들의 주가 이외의 기타 정보를 업데이트
    def update_all_db_etc(self):
        # valuation_price : 평가금액
        # 평가금액 = (보유주 현재가 * 보유주 수량) - (총 구매금액 * 수수료) - (보유주 현재가 * 보유주 수량 * (수수료 + 세금))
        query = f"update all_stocks " \
              f"set " \
              f"valuation_price = " \
              f"round((present_price  * holding_amount) - item_total_purchase * {self.fees_rate} - " \
              f"present_price*holding_amount*{self.fees_rate + self.tax_rate}) " \
              f"where sell_date = '{0}'"
        self.engine_simul.execute(query)

        # rate              : 현재 실시간 수익률
        # valuation_profit  : 수익 금액
        # 수익 금액 = 평가금액 - 총 구매금액
        # 수익률   = 수익금액 / 구매금액 * 100
        query = "update all_stocks " \
                "set " \
                "rate= round((valuation_price - item_total_purchase)/item_total_purchase*100,2), " \
                "valuation_profit = valuation_price - item_total_purchase " \
                "where sell_date = '0'"
        self.engine_simul.execute(query)

    # 매도 함수
    def auto_trade_sell_stock(self,date,i):
        # 매도할 리스트를 저장
        sell_list=self.get_sell_list(i)

        for j in range(len(sell_list)):
            sell_code=sell_list[j][0]
            sell_rate=sell_list[j][1]
            present_price=sell_list[j][2]
            valuation_profit=sell_list[j][3]

            if sell_rate<0:
                print("손절 매도!")
                print("=========================================")
                print("종목 코드    : ",sell_code)
                print("수익        : ",valuation_profit)
                print("수익률       : ",sell_rate)
                print("=========================================")

            else:
                print("익절 매도!")
                print("=========================================")
                print("종목 코드    : ",sell_code)
                print("수익        : ",valuation_profit)
                print("수익률       : ",sell_rate)
                print("=========================================")

            # 매도 결과를 데이터베이스에 반영
            self.sell_send_order(date,present_price,sell_rate,sell_code)

    # 매도한 결과를 all_stocks에 반영하는 함수
    def sell_send_order(self,min,sell_price,sell_rate,code):
        query=f"update all_stocks " \
              f"set " \
              f"sell_date='{min}', sell_price='{sell_price}', sell_rate='{sell_rate}' " \
              f"where code='{code}' and sell_date='{0}' order by buy_date desc limit 1"
        self.engine_simul.execute(query)
        # 매도 후 정산
        self.check_balance()

    # 매도함수를 이용하여 매도할 종목을 가져오는 함수
    def get_sell_list(self,i):
        sell_list=None

        # (5,20) 데드크로스
        # 또는 손절 기준 수익률 이하로 떨어졌을 경우 매도
        if self.sell_list_num==1:
            query=f"select code,rate, present_price,valuation_price from all_stocks " \
                  f"where sell_date='0' and (clo5<clo20 or rate<='{self.losscut_point}') group by code"
            sell_list=self.engine_simul.execute(query).fetchall()

        # (20,60) 데드크로스
        elif self.sell_list_num==2:
            query=f"select code,rate, present_price,valuation_price from all_stocks " \
                  f"where sell_date='0' and (clo20<clo60 or rate<='{self.losscut_point}') group by code"
            sell_list=self.engine_simul.execute(query).fetchall()

        # RSI
        #elif self.sell_algorithm==3:
        # RMI
        #elif self.sell_algorithm==4:

        else:
            logger.error("Invalid sell algorithm setting...")

        return sell_list

    # 남은 금액을 확인하는 함수
    # 남은 금액이 최소 보유금 + 투자단위금액 이상이면 True, 아니면 False 반환
    def jango_check(self):
        if int(self.d2_deposit)>=int(self.limit_money)+int(self.invest_unit):
            return True
        else:
            return False

    # 매수 함수
    def auto_trade_stock_realtime(self,min,date_rows_today,date_rows_yesterday):
        # self.df_realtime_daily_buy_list에 있는 모든 종목을 매수
        for i in range(self.len_df_realtime_daily_buy_list):
            # 매수할 잔액이 남아있다면
            if self.jango_check():
                code=self.df_realtime_daily_buy_list.loc[i,'code'].rjust(6,"0")
                code_name=self.df_realtime_daily_buy_list.loc[i,'code_name']

                # 분별 시뮬레이팅인 경우
                if self.use_min:
                    # 분별 종목데이터가 존재하지 않는 항목이라면 매수하지 않음
                    if not self.is_min_craw_table_exist(code_name):
                        continue
                # 일별 시뮬레이팅인 경우
                else:
                    # 일별 종목데이터가 존재하지 않는 항목이라면 매수하지 않음
                    if not self.is_daily_craw_table_exist(code_name):
                        continue

                # 일별 시뮬레이팅인 경우
                if not self.use_min:
                    price=self.get_now_open_price_by_date(code,date_rows_today)
                # 분별 시뮬레이팅인 경우
                else:
                    price=self.get_now_close_price_by_min(code_name,min)

                # 전날 종가를 저장
                yes_close=self.get_yes_close_price_by_date(code,date_rows_yesterday)

                # 종목명 또는 시작가가 존재하지 않는다면 매수하지 않음
                if code_name==False or price==0 or price==False:
                    continue

                # 분별 시뮬레이팅인 경우
                if self.use_min and not self.only_nine_buy and self.trade_check_num:
                    open=self.get_now_open_price_by_date(code,date_rows_today)      # 시가
                    sum_volume=self.get_now_volume_by_min(code_name,min)            # 당일 누적 거래량

                    if open and sum_volume:
                        # 실시간 매수조건에 부합하지 않는 경우 매수하지 않음
                        if not self.trade_check(self.df_realtime_daily_buy_list.loc[i],open,price,sum_volume):
                            continue

                # 매수주문
                self.invest_send_order(min,code,code_name,price,yes_close,i)
            else:
                break

    # min_craw 데이터베이스에 code_name 테이블이 존재하는지 확인하는 함수
    def is_min_craw_table_exist(self,code_name):
        query = f"select 1 from information_schema.tables where table_schema = 'min_craw' and table_name = '{code_name}'"
        result = self.engine_craw.execute(query).fetchall()
        if len(result) == 1:
            return True
        else:
            return False

    # daily_craw 데이터베이스에 code_name 테이블이 존재하는지 확인하는 함수
    def is_daily_craw_table_exist(self,code_name):
        query = f"select 1 from information_schema.tables where table_schema = 'daily_craw' and table_name = '{code_name}'"
        result = self.engine_daily_craw.execute(query).fetchall()
        if len(result) == 1:
            return True
        else:
            return False

    # 특정 날짜의 테이블에서 특정 종목의 시가를 가져오는 함수
    def get_now_open_price_by_date(self,code,date):
        query=f"select open from `{date}` where code = '{code}' group by code"
        open=self.engine_daily_buy_list.execute(query).fetchall()
        if len(open)==1:
            return open[0][0]
        else:
            return False

    # 전날 종가(close)를 가져오는 함수
    def get_yes_close_price_by_date(self,code,date):
        query = f"select close from `{date}` where code = '{code}' group by code"
        result = self.engine_daily_buy_list.execute(query).fetchall()
        if len(result) == 1:
            return result[0][0]
        else:
            return False

    # 분별 현재 누적 거래량을 가져오는 함수
    def get_now_volume_by_min(self,code_name,min):
        query= f"select sum_volume from `{code_name}` " \
               f"where date = '{min}' and open != 0 and volume !=0 order by sum_volume desc limit 1"
        result = self.engine_craw.execute(query).fetchall()
        if len(result) == 1:
            return result[0][0]
        else:
            return False

    # 실시간 주가를 분석하여 매수 여부를 결정하는 함수
    # param     :   df_row - 매수 종목 리스트
    #               open_price - 시가
    #               current_price - 현재가
    #               current_sum_volume - 현재 누적 거래량
    # return    :   True인 경우 매수, False인 경우 매수하지 않음
    def trade_check(self,df_row,open_price,current_price,current_sum_volume):
        code_name = df_row['code_name']
        yes_vol20 = df_row['vol20']
        yes_close = df_row['close']
        yes_high = df_row['high']
        yes_low = df_row['low']
        yes_volume = df_row['volume']

        # 실시간 거래 대금 체크 알고리즘

        # 어제 종가 보다 현재가가 증가했고, 거래 대금이 어제 거래대금에 비해서 x배 올라갔을 때 매수
        if self.trade_check_num == 1:
            yes_total_tr_price = yes_close * yes_volume                     # 전날 거래 대금
            current_total_tr_price = current_price * current_sum_volume     # 현재 거래 대금

            if current_price > yes_close and current_total_tr_price > yes_total_tr_price * self.volume_up:
                return True
            else:
                return False

        # 현재가가 매수 가격 최저 범위와 매수 가격 최고 범위 안에 들어와 있다면 매수
        elif self.trade_check_num == 2:
            min_buy_limit = int(yes_close) * self.invest_min_limit_rate     # 매수가격 최저 범위
            max_buy_limit = int(yes_close) * self.invest_limit_rate         # 매수가격 최고 범위

            if min_buy_limit < current_price < max_buy_limit:
                return True
            else:
                return False

        # 래리 윌리엄스 변동성 돌파 알고리즘(매수)
        elif self.trade_check_num == 3:
            # 변동폭(range): 전일 고가(yes_high)에서 전일 저가(yes_low)를 뺀 가격
            # 매수시점 : 현재가 > 시작가 + (변동폭 * k)  [k는 0~1 사이 수]
            range = yes_high - yes_low
            if open_price + range * self.rarry_k < current_price:
                return True
            else:
                return False

        else:
            logger.error("Invalid trade_check_num")

    # 데이터베이스에 매수 내역 업데이트
    def invest_send_order(self,date,code,code_name,price,yes_close,j):
        # 가격이 invest_unit보다 작은 경우 매수
        if price < self.invest_unit:
            # 매수하는 경우 all_stocks에 해당 내역을 추가
            self.db_to_all_stocks(date,self.df_realtime_daily_buy_list,j,code,code_name,price,yes_close)

            # 매수를 성공적으로 했으면 realtime_daily_buy_list 테이블의 check_item 에 매수 시간을 설정
            self.update_realtime_daily_buy_list(code, date)

            # 정산
            self.check_balance()

    # all_stocks 테이블에 추가하는 함수
    def db_to_all_stocks(self,min,df,index,code,code_name,purchase_price,yesterday_close):
        self.df_all_stocks.loc[0,'code']=code
        self.df_all_stocks.loc[0,'code_name']=code_name
        self.df_all_stocks.loc[0,'rate']=float(-0.33)

        if yesterday_close:
            self.df_all_stocks.loc[0, 'purchase_rate'] = round(
                (float(purchase_price) - float(yesterday_close)) / float(yesterday_close) * 100, 2)

        self.df_all_stocks.loc[0, 'purchase_price'] = purchase_price
        self.df_all_stocks.loc[0, 'present_price'] = purchase_price

        self.df_all_stocks.loc[0, 'holding_amount'] = int(self.invest_unit / purchase_price)
        self.df_all_stocks.loc[0, 'buy_date'] = min
        self.df_all_stocks.loc[0, 'item_total_purchase'] = self.df_all_stocks.loc[0, 'purchase_price'] * \
                                                            self.df_all_stocks.loc[0, 'holding_amount']

        self.today_invest_price = self.today_invest_price + self.df_all_stocks.loc[0, 'item_total_purchase']

        self.df_all_stocks.loc[0, 'chegyul_check'] = 0
        self.df_all_stocks.loc[0, 'id'] = 0
        self.df_all_stocks.loc[0, 'invest_unit'] = self.invest_unit

        self.df_all_stocks.loc[0, 'yes_close'] = yesterday_close
        self.df_all_stocks.loc[0, 'close'] = df.loc[index, 'close']

        self.df_all_stocks.loc[0, 'open'] = df.loc[index, 'open']
        self.df_all_stocks.loc[0, 'high'] = df.loc[index, 'high']
        self.df_all_stocks.loc[0, 'low'] = df.loc[index, 'low']
        self.df_all_stocks.loc[0, 'volume'] = df.loc[index, 'volume']

        self.df_all_stocks.loc[0,'d1_diff']=int(df.loc[index,'d1_diff'])
        self.df_all_stocks.loc[0, 'd1_diff_rate'] = float(df.loc[index, 'd1_diff_rate'])

        self.df_all_stocks.loc[0, 'clo5'] = df.loc[index, 'clo5']
        self.df_all_stocks.loc[0, 'clo10'] = df.loc[index, 'clo10']
        self.df_all_stocks.loc[0, 'clo20'] = df.loc[index, 'clo20']
        self.df_all_stocks.loc[0, 'clo60'] = df.loc[index, 'clo60']
        self.df_all_stocks.loc[0, 'clo120'] = df.loc[index, 'clo120']

        if df.loc[index, 'clo5_diff_rate'] is not None:
            self.df_all_stocks.loc[0, 'clo5_diff_rate'] = float(df.loc[index, 'clo5_diff_rate'])
        if df.loc[index, 'clo10_diff_rate'] is not None:
            self.df_all_stocks.loc[0, 'clo10_diff_rate'] = float(df.loc[index, 'clo10_diff_rate'])
        if df.loc[index, 'clo20_diff_rate'] is not None:
            self.df_all_stocks.loc[0, 'clo20_diff_rate'] = float(df.loc[index, 'clo20_diff_rate'])
        if df.loc[index, 'clo60_diff_rate'] is not None:
            self.df_all_stocks.loc[0, 'clo40_diff_rate'] = float(df.loc[index, 'clo60_diff_rate'])
        if df.loc[index, 'clo120_diff_rate'] is not None:
            self.df_all_stocks.loc[0, 'clo60_diff_rate'] = float(df.loc[index, 'clo120_diff_rate'])

        self.df_all_stocks.loc[0, 'valuation_profit'] = int(0)

        self.df_all_stocks=self.df_all_stocks.fillna(0)

        # 거래이력 테이블이 이미 존재한다면 데이터 추가
        if self.is_simul_table_exist(self.db_name, "all_stocks"):
            self.df_all_stocks.to_sql('all_stocks', self.engine_simul, if_exists='append')
        # 테이블이 존재하지 않는다면 생성
        else:
            self.df_all_stocks.to_sql('all_stocks', self.engine_simul, if_exists='replace')

    # 매수할 리스트(realtime_daily_buy_list)에서 특정 종목을 매수한 경우 check_item칼럼에 매수한 날짜를 저장하는 함수
    def update_realtime_daily_buy_list(self,code,min):
        query = f"update realtime_daily_buy_list set check_item = '{min}' where code = '{code}'"
        self.engine_simul.execute(query)

    # jango 테이블을 생성 및 데이터를 추가하는 함수
    def db_to_jango(self,date_rows_today):
        self.check_balance()
        # 거래이력(transaction)테이블이 존재하지 않는다면 return
        if not self.is_simul_table_exist(self.db_name,"all_stocks"):
            return

        self.jango.loc[0,'date']=date_rows_today                                          # 구매일
        self.jango.loc[0, 'sum_valuation_profit'] = self.sum_valuation_profit             # 총평가금액
        self.jango.loc[0, 'total_profit'] = self.total_valuation_profit                   # 총수익
        self.jango.loc[0, 'today_profit'] = self.get_today_profit(date_rows_today)        # 당일수익

        self.jango.loc[0, 'today_profitcut_count'] = self.get_today_profitcut_count(date_rows_today)  # 당일 익절종목 수
        self.jango.loc[0, 'today_losscut_count'] = self.get_today_losscut_count(date_rows_today)      # 당일 손절종목 수
        self.jango.loc[0, 'today_profitcut'] = self.get_sum_today_profitcut(date_rows_today)          # 당일 익절금액
        self.jango.loc[0, 'today_losscut'] = self.get_sum_today_losscut(date_rows_today)              # 당일 손절금액

        self.jango.loc[0, 'd2_deposit'] = self.d2_deposit                                 # 예수금
        self.jango.loc[0, 'total_possess_count'] = self.get_total_possess_count()         # 보유종목 수
        self.jango.loc[0, 'today_buy_count'] = 0                                          # 오늘 구매한 종목수
        self.jango.loc[0, 'total_invest'] = self.total_invest_price                       # 총 투자금액

        self.jango.loc[0, 'sum_item_total_purchase'] = self.get_sum_item_total_purchase() # 총매입금액
        self.jango.loc[0, 'total_evaluation'] = self.get_sum_valuation_price()            # 총평가금액
        try:
            self.jango.loc[0, 'today_rate'] = round(
                (float(self.jango.loc[0, 'total_evaluation']) -
                 float(self.jango.loc[0, 'sum_item_total_purchase'])) /
                float(self.jango.loc[0, 'sum_item_total_purchase']) * (100 - 0.33), 2)    # 당일 기준 수익률
        except ZeroDivisionError:
            pass

        self.jango.loc[0, 'today_invest_price'] = float(self.today_invest_price)          # 당일 투자금액
        self.jango.loc[0, 'today_sell_price'] = self.get_sum_today_sell_price(date_rows_today)
        self.jango.loc[0, 'volume_limit'] = self.volume_limit
        self.jango.loc[0, 'sell_point'] = self.sell_point
        self.jango.loc[0, 'invest_unit'] = self.invest_unit

        self.jango.loc[0, 'limit_money'] = self.limit_money
        self.jango.loc[0, 'total_profitcut'] = self.get_sum_total_profitcut()
        self.jango.loc[0, 'total_losscut'] = self.get_sum_total_losscut()
        self.jango.loc[0, 'total_profitcut_count'] = self.get_sum_total_profitcut_count()
        self.jango.loc[0, 'total_losscut_count'] = self.get_sum_total_losscut_count()

        # 데이터베이스에 테이블 추가
        self.jango.to_sql('jango_data', self.engine_simul, if_exists='append')

        # 매도종목에 대한 당일 수익
        query = f"update jango_data " \
                f"set " \
                f"today_earning_rate =round(today_profit / total_invest * 100, 2) WHERE date='{date_rows_today}'"
        self.engine_simul.execute(query)

    # 당일 수익을 계산하는 함수
    def get_today_profit(self,date):
        query="SELECT sum(valuation_profit) from all_stocks where sell_date like '%s'"
        result=self.engine_simul.execute(query%("%%"+date+"%%")).fetchall()
        return result[0][0]

    # 당일 익절 종목 수를 반환하는 함수
    def get_today_profitcut_count(self,date):
        query = "SELECT count(code) from all_stocks where sell_date like '%s' and sell_rate>='%s'"
        return self.engine_simul.execute(query % ("%%" + date + "%%", 0)).fetchall()[0][0]

    # 당일 손절 종목 수를 반환하는 함수
    def get_today_losscut_count(self, date):
        query = "SELECT count(code) from all_stocks where sell_date like '%s' and sell_rate<'%s'"
        return self.engine_simul.execute(query % ("%%" + date + "%%", 0)).fetchall()[0][0]

    # 당일 익절 금액을 반환하는 함수
    def get_sum_today_profitcut(self, date):
        query = "SELECT sum(valuation_profit) from all_stocks where sell_date like '%s' and valuation_profit >= '%s' "
        return self.engine_simul.execute(query % ("%%" + date + "%%", 0)).fetchall()[0][0]

    # 당일 손절 금액을 반환하는 함수
    def get_sum_today_losscut(self, date):
        query = "SELECT sum(valuation_profit) from all_stocks where sell_date like '%s' and valuation_profit < '%s' "
        return self.engine_simul.execute(query % ("%%" + date + "%%", 0)).fetchall()[0][0]

    # 총 보유한 종목 수를 반환하는 함수
    def get_total_possess_count(self):
        query = "select count(code) from all_stocks where sell_date = '%s'"
        return self.engine_simul.execute(query % (0)).fetchall()[0][0]

    # 총 매입금액을 계산하는 함수
    def get_sum_item_total_purchase(self):
        query = "SELECT sum(item_total_purchase) from all_stocks where sell_date = '%s'"
        result = self.engine_simul.execute(query % (0)).fetchall()[0][0]
        if result is not None:
            return result
        else:
            return 0

    # 총평가금액을 계산하는 함수
    def get_sum_valuation_price(self):
        query = "SELECT sum(valuation_price) from all_stocks where sell_date = '%s'"
        result = self.engine_simul.execute(query % (0)).fetchall()[0][0]
        if result is not None:
            return result
        else:
            return 0

    # 당일 매도금액을 계산하는 함수
    def get_sum_today_sell_price(self, date):
        query = "SELECT sum(valuation_price) from all_stocks where sell_date like '%s'"
        return self.engine_simul.execute(query % ("%%" + date + "%%")).fetchall()[0][0]

    # 총 익절금액을 계산하는 함수
    def get_sum_total_profitcut(self):
        query = "SELECT sum(valuation_profit) from all_stocks where sell_date != 0 and valuation_profit >= '%s' "
        return self.engine_simul.execute(query % (0)).fetchall()[0][0]

    # 총 손절금액을 계산하는 함수
    def get_sum_total_losscut(self):
        query = "SELECT sum(valuation_profit) from all_stocks where sell_date != 0 and valuation_profit < '%s' "
        return self.engine_simul.execute(query % (0)).fetchall()[0][0]

    # 총 익절종목수를 반환하는 함수
    def get_sum_total_profitcut_count(self):
        query = "select count(code) from all_stocks where sell_date != 0 and valuation_profit >= '%s'"
        return self.engine_simul.execute(query % (0)).fetchall()[0][0]

    # 총 손절종목수를 반환하는 함수
    def get_sum_total_losscut_count(self):
        query = "select count(code) from all_stocks where sell_date != 0 and valuation_profit < '%s' "
        return self.engine_simul.execute(query % (0)).fetchall()[0][0]

    # 날짜별 시뮬레이팅 함수
    def simul_by_date(self,date_rows_today,date_rows_yesterday,i):
        # 시뮬레이팅 전 변수 초기화
        self.daily_variable_setting()

        # daily_buy_list에 시뮬레이팅 할 날짜에 해당하는 테이블과 전 날 테이블이 존재하는지 확인
        if self.is_date_exist(date_rows_today) and self.is_date_exist(date_rows_yesterday):
            # 당일 매수 할 종목 저장
            self.db_to_realtime_daily_buy_list(date_rows_today, date_rows_yesterday, i)
            # 매수/매도
            self.trading_by_date(date_rows_today, date_rows_yesterday, i)

            if self.is_simul_table_exist(self.db_name, "all_stocks") and len(self.get_data_from_possessed_item()) != 0:
                # 보유 중인 종목들의 주가를 일별로 업데이트
                self.update_all_db_by_date(date_rows_today,option="ALL")

            # 정산
            self.db_to_jango(date_rows_today)

        else:
            print("날짜 테이블이 존재하지 않습니다.")

    # 날짜별 거래 함수
    def trading_by_date(self,date_rows_today,date_rows_yesterday,i):
        self.show_info(date_rows_today)

        # 보유주 정보 업데이트
        if self.is_simul_table_exist(self.db_name, "all_stocks") and len(self.get_data_from_possessed_item()) != 0:
            self.update_all_db_by_date(date_rows_today,option="OPEN")
            self.update_all_db_etc()

            # 매도
            self.auto_trade_sell_stock(date_rows_today,i)

            # 매수할 잔액이 존재한다면 매수
            if self.jango_check():
                self.auto_trade_stock_realtime(str(date_rows_today) + "0900", date_rows_today, date_rows_yesterday)

        # 매도 리스트가 존재하지 않는다면 매수만 진행
        else:
            if self.jango_check():
                self.auto_trade_stock_realtime(str(date_rows_today) + "0900", date_rows_today, date_rows_yesterday)

    # daily_buy_list 데이터베이스에서 가장 최근의 날짜 테이블을 가져오는 함수
    def get_recent_daily_buy_list_date(self):
        query="select TABLE_NAME from information_schema.tables " \
              "where table_schema = 'daily_buy_list' and TABLE_NAME like '%s' order by table_name desc limit 1"
        row = self.engine_daily_buy_list.execute(query % ("20%%")).fetchall()

        if len(row) == 0:
            return False
        return row[0][0]

    # 최근 daily_buy_list의 날짜 테이블에서 code에 해당하는 데이터만 가져오는 함수
    def get_daily_buy_list_by_code(self,code,date):
        query = f"select * from `{date}` where code = '{code}' group by code"

        daily_buy_list = self.engine_daily_buy_list.execute(query).fetchall()

        df_daily_buy_list = DataFrame(daily_buy_list,
                                      columns=['index', 'index2', 'date', 'check_item',
                                               'code', 'code_name', 'd1_diff', 'd1_diff_rate',
                                               'close', 'open','high', 'low', 'volume',
                                               'clo5', 'clo10', 'clo20', 'clo60', 'clo120',
                                               "clo5_diff_rate", "clo10_diff_rate", "clo20_diff_rate",
                                               "clo60_diff_rate", "clo120_diff_rate",
                                               'yes_clo5', 'yes_clo10', 'yes_clo20', 'yes_clo60','yes_clo120',
                                               'vol5', 'vol10', 'vol20', 'vol60', 'vol120'])
        return df_daily_buy_list

    # 현재 특정 종목의 종가를 가져오는 함수
    def get_now_close_price_by_date(self,code,date):
        query=f"select close from `{date}` where code='{code}' group by code"
        result=self.engine_daily_buy_list.execute(query).fetchall()

        if len(result)==1:
            return result[0][0]
        else:
            return False

    # 모든 테이블을 삭제하는 함수
    def delete_table_data(self):
        if self.is_simul_table_exist(self.db_name,"all_stocks"):
            query="drop table all_stocks"
            self.engine_simul.execute(query)

        if self.is_simul_table_exist(self.db_name,"jango_data"):
            query="drop table jango_data"
            self.engine_simul.execute(query)

        if self.is_simul_table_exist(self.db_name,"realtime_daily_buy_list"):
            query="drop table realtime_daily_buy_list"
            self.engine_simul.execute(query)

    # 코드값으로 해당하는 종목명을 가져오는 함수
    def get_name_by_code(self,code):
        query=f"select code_name from stock_item_all where code='{code}'"
        code_name=self.engine_daily_buy_list.execute(query)
        if code_name:
            return code_name[0][0]
        else:
            return False

    # 몇개의 주를 살지 계산하는 함수
    def buy_num_count(self,invest_unit,present_price):
        return int(int(invest_unit)/int(present_price))