import numpy as np
from datetime import datetime

class BuySell_Daily:

    def countYangBong(self, data, i):
        count = 0
        for c in range(5):
            if data['open'][i-c] < data['close'][i-c]:
                count += 1
        return count

    def getBuyPrice(self, ticker, data, data_scaled, i, BS=None):
        buy_ymd, buy_price, buy_count, buy_weight, buy_type, buy_cut = None, 0, 0, 1, '', None

        sub_i = None
        for c in range(i-1, i-5, -1):
            if 0 < BS['buy_count'][c] and 0 < BS['buy_price'][c]:
                sub_i = c
                break
        sub_check = False
        if sub_i is not None:
            sub_check = True
            for c in range(sub_i, i+1):
                if data['close'].iloc[c+1] < BS['buy_price'][c] * 0.99:
                    sub_check = False
                    break
        if sub_check:
            buy_price = data['close'].iloc[i] - 2 * ticker['unit']
            buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
            buy_type = ''
        else:
            tmp_buy_ymd, tmp_buy_price, tmp_buy_count, tmp_buy_type, tmp_buy_cut = self.getBuyPrice_BBAND(ticker, data, data_scaled, i, BS)
            if 0 < tmp_buy_count:
                buy_ymd = tmp_buy_ymd; buy_price = tmp_buy_price; buy_count = tmp_buy_count; buy_type = tmp_buy_type; buy_cut = tmp_buy_cut
            tmp_buy_ymd, tmp_buy_price, tmp_buy_count, tmp_buy_type, tmp_buy_cut = self.getBuyPrice_PolyLine(ticker, data, data_scaled, i, BS)
            if 0 < tmp_buy_count:
                buy_ymd = tmp_buy_ymd; buy_price = tmp_buy_price; buy_count = tmp_buy_count; buy_type = tmp_buy_type; buy_cut = tmp_buy_cut
            tmp_buy_ymd, tmp_buy_price, tmp_buy_count, tmp_buy_type, tmp_buy_cut = self.getBuyPrice_Slow(ticker, data, data_scaled, i, BS)
            if 0 < tmp_buy_count:
                buy_ymd = tmp_buy_ymd; buy_price = tmp_buy_price; buy_count = tmp_buy_count; buy_type = tmp_buy_type; buy_cut = tmp_buy_cut

        return buy_ymd, buy_price, buy_count, buy_type, buy_cut

    def getSellPrice(self, ticker, data, data_scaled, i, BS=None):
        sell_price, sell_count, sell_type = 0, 1, ''
        sell_type_list = []

        #tmp_sell_price, tmp_sell_type_list = self.getSellPrice_Umbong(ticker, data, data_scaled, i, BS)
        #sell_type_list += tmp_sell_type_list

        #sell_price = tmp_sell_price

        if 0 < len(sell_type_list) or 0 < sell_price:
            sell_type = ','.join(list(set(sell_type_list)))

        return sell_price, sell_count, sell_type

    """"""""""""""""""
    """"""""""""""""""

    def getBuyPrice_BBAND(self, ticker, data, data_scaled, i, BS):

        buy_ymd, buy_price, buy_count, buy_weight, buy_type, buy_cut = None, 0, 0, 1, '', None

        check = False

        if 60 < i:

            sub_check1, sub_check2 = False, False
            for c in range(i-20, i):
                if not sub_check1 and data['bb_width'].iloc[i-1] < data['bb_width'].iloc[i] and data['bb_width'].iloc[i] < 5:
                    sub_check1 = True
                if sub_check1 and not sub_check2 and data['upper_20'].iloc[i] < data['high'].iloc[i]:
                    sub_check2 = True
                    break

            if sub_check1 and sub_check2:
                if data_scaled['poly_120'].iloc[i-1] < data_scaled['poly_120'].iloc[i]:
                    check = True
                    buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                    buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                    buy_weight = 30
                    buy_type = 'bband'

        if check:
            buy_ymd = data['ymd'].iloc[i]
            buy_price = data['close'].iloc[i] - 2 * ticker['unit']
            buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]

        return buy_ymd, buy_price, buy_count, buy_type, buy_cut


    """"""""""""""""""
    """"""""""""""""""

    def getBuyPrice_PolyLine(self, ticker, data, data_scaled, i, BS):

        buy_ymd, buy_price, buy_count, buy_weight, buy_type, buy_cut = None, 0, 0, 1, '', None

        check = False

        if 60 < i:

            if data_scaled['poly_60'].iloc[i-1] < 0 and data_scaled['poly_120'].iloc[i-1] < -0.003:
                if data_scaled['poly_60'].iloc[i-1] <= data_scaled['poly_120'].iloc[i-1] and data_scaled['poly_120'].iloc[i] < data_scaled['poly_60'].iloc[i]:
                    check = True
                    buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                    buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                    buy_weight = 30
                    buy_type = 'poly'


            if data_scaled['poly_240'].iloc[i - 1] < data_scaled['poly_240'].iloc[i] and data['slowk_240'].iloc[i] < 50:
                if data['close'].iloc[i - 1] < data['avg240'].iloc[i-1] and data['avg240'].iloc[i] < data['close'].iloc[i]:
                    check = True
                    buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                    buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                    buy_weight = 30
                    buy_type = 'poly_240'
                    #buy_cut = data['support'].iloc[i]

            if data_scaled['poly_480'].iloc[i - 1] < data_scaled['poly_480'].iloc[i] and data['slowk_480'].iloc[i] < 50:
                if data['close'].iloc[i - 1] < data['avg480'].iloc[i-1] and data['avg480'].iloc[i] < data['close'].iloc[i]:
                    check = True
                    buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                    buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                    buy_weight = 30
                    buy_type = 'poly_480'
                    #buy_cut = data['support'].iloc[i]

        if check:
            buy_ymd = data['ymd'].iloc[i]
            buy_price = data['close'].iloc[i] - 2 * ticker['unit']
            buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]

        return buy_ymd, buy_price, buy_count, buy_type, buy_cut

    def getBuyPrice_Slow(self, ticker, data, data_scaled, i, BS):

        buy_ymd, buy_price, buy_count, buy_weight, buy_type, buy_cut = None, 0, 0, 1, '', None

        check = False

        if 5 < i:

            #if data_scaled["disparity_diff_60_20_rate"].iloc[i] < -0.5:

            if data_scaled["disparity_diff_60_20_rate"].iloc[i] < -0.5 and data_scaled["disparity_diff_60_20_rate"].iloc[i-1] < data_scaled["disparity_diff_60_20_rate"].iloc[i]:

                if data_scaled['slowk_20'].iloc[i-1] <= data_scaled['slowd_20'].iloc[i-1] < 0:
                    if data_scaled['slowd_20'].iloc[i] < data_scaled['slowk_20'].iloc[i] < 0:
                        check = True
                        buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                        buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                        buy_type = 'slowk_20'
                        #buy_cut = data['support'].iloc[i]

                if data_scaled['slowk_60'].iloc[i-1] <= data_scaled['slowd_60'].iloc[i-1] < 0:
                    if data_scaled['slowd_60'].iloc[i] < data_scaled['slowk_60'].iloc[i] < 0:
                        check = True
                        buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                        buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                        buy_type = 'slowk_60'
                        #buy_cut = data['support'].iloc[i]

                if data_scaled['slowk_120'].iloc[i-1] <= data_scaled['slowd_120'].iloc[i-1] < 0:
                    if data_scaled['slowd_120'].iloc[i] < data_scaled['slowk_120'].iloc[i] < 0:
                        check = True
                        buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                        buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                        buy_type = 'slowk_120'
                        #buy_cut = data['support'].iloc[i]

                if data_scaled['slowk_240'].iloc[i-1] <= data_scaled['slowd_240'].iloc[i-1] < 0:
                    if data_scaled['slowd_240'].iloc[i] < data_scaled['slowk_240'].iloc[i] < 0:
                        check = True
                        buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                        buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                        buy_type = 'slowk_240'
                        #buy_cut = data['support'].iloc[i]

                if data['slowk_480'].iloc[i - 1] < data['slowd_480'].iloc[i - 1] < 40:
                    if data['slowd_480'].iloc[i] < data['slowk_480'].iloc[i]:
                        check = True
                        buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                        buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                        buy_type = 'slowk_1440'
                        #buy_cut = data['support'].iloc[i]

                if data['avg240'].iloc[i - 1] < data['avg240'].iloc[i]:
                    if data_scaled['poly_480'].iloc[i - 1] <= 0 and 0 < data_scaled['poly_480'].iloc[i]:
                        check = True
                        buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                        buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                        buy_type = 'poly_480'
                        #buy_cut = data['support'].iloc[i]

                if data_scaled['poly_240'].iloc[i - 1] < data_scaled['poly_240'].iloc[i] and data['slowk_240'].iloc[i] < 50:
                    if data['close'].iloc[i - 1] < data['avg720'].iloc[i-1] and data['avg720'].iloc[i] < data['close'].iloc[i]:
                        check = True
                        buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                        buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                        buy_type = 'poly_240'
                        #buy_cut = data['support'].iloc[i]

                if data_scaled['poly_480'].iloc[i - 1] < data_scaled['poly_480'].iloc[i] and data['slowk_480'].iloc[i] < 50:
                    if data['close'].iloc[i - 1] < data['avg1440'].iloc[i-1] and data['avg1440'].iloc[i] < data['close'].iloc[i]:
                        check = True
                        buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                        buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                        buy_type = 'poly_480'
                        #buy_cut = data['support'].iloc[i]

                if data["slowk_10"].iloc[i-1] < data["slowk_10"].iloc[i] < 20:
                    check = True
                    buy_price = data['close'].iloc[i] - 2 * ticker['unit']
                    buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]
                    buy_type = 'slowk_10'
                    # buy_cut = data['support'].iloc[i]

        if check:
            buy_ymd = data['ymd'].iloc[i]
            buy_price = data['close'].iloc[i] - 2 * ticker['unit']
            buy_count = (buy_weight * ticker['MAX_BUY']) / data['close'].iloc[i]

        return buy_ymd, buy_price, buy_count, buy_type, buy_cut