import os,sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from v2realbot.strategy.base import StrategyState
from v2realbot.strategy.StrategyOrderLimitVykladaciNormalizedMYSELL import StrategyOrderLimitVykladaciNormalizedMYSELL
from v2realbot.enums.enums import RecordType, StartBarAlign, Mode, Account, OrderSide, OrderType
from v2realbot.indicators.indicators import ema
from v2realbot.indicators.oscillators import rsi
from v2realbot.utils.utils import ltp, isrising, isfalling,trunc,AttributeDict, zoneNY, price2dec, print, safe_get, get_tick, round2five, is_open_rush, is_close_rush, eval_cond_dict
from datetime import datetime
#from icecream import install, ic
#from rich import print
from threading import Event
from msgpack import packb, unpackb
import asyncio
import os
from traceback import format_exc
import inspect

print(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
""""
MYSELL, CBAR

Rychloobratka KLARA 

- profit 0.005
- buy signal nejspis RSI, cilem co nejvic obchodu - rychle ven



"""
stratvars = AttributeDict(maxpozic = 400,
                          def_mode_from = 200,
                          chunk = 10,
                          MA = 2,
                          Trend = 2,
                          profit = 0.02,
                          def_profit = 0.01,
                          lastbuyindex=-6,
                          pendingbuys={},
                          limitka = None,
                          limitka_price = None,
                          jevylozeno=0,
                          vykladka=5,
                          curve = [0.01, 0.01, 0.01, 0, 0.02, 0.02, 0.01,0.01, 0.01,0.03, 0.01, 0.01, 0.01,0.04, 0.01,0.01, 0.01,0.05, 0.01,0.01, 0.01,0.01, 0.06,0.01, 0.01,0.01, 0.01],
                          curve_def = [0.02, 0.02, 0.02, 0, 0, 0.02, 0, 0, 0, 0.02],
                          blockbuy = 0,
                          ticks2reset = 0.04,
                          consolidation_bar_count = 10,
                          slope_lookback = 300,
                          lookback_offset = 20,
                          minimum_slope = -0.05,
                          first_buy_market = False
                          )
##toto rozparsovat a strategii spustit stejne jako v main
toml_string = """
[[strategies]]
name = "V1 na BAC"
symbol = "BAC"
script = "ENTRY_backtest_strategyVykladaci"
class = "StrategyOrderLimitVykladaci"
open_rush = 0
close_rush = 0
[strategies.stratvars]
maxpozic = 200
chunk = 10
MA = 6
Trend = 5
profit = 0.02
lastbuyindex=-6
pendingbuys={}
limitka = "None"
jevylozeno=0
vykladka=5
curve = [0.01, 0.01, 0.01,0.01, 0.02, 0.01,0.01, 0.01,0.03, 0.01, 0.01, 0.01,0.04, 0.01,0.01, 0.01,0.05, 0.01,0.01, 0.01,0.01, 0.06,0.01, 0.01,0.01, 0.01]
blockbuy = 0
ticks2reset = 0.04
[[strategies.add_data]]
symbol="BAC"
rectype="bar"
timeframe=5
update_ltp=true
align="round"
mintick=0
minsize=100
exthours=false
"""

def next(data, state: StrategyState):
    print(10*"*","NEXT START",10*"*")
    #ic(state.avgp, state.positions)
    #ic(state.vars)
    #ic(data)

    #
    def is_defensive_mode():
        akt_pozic = int(state.positions)
        max_pozic = int(state.vars.maxpozic)
        def_mode_from = safe_get(state.vars, "def_mode_from",max_pozic/2)
        if akt_pozic >= int(def_mode_from):
            #state.ilog(e=f"DEFENSIVE mode ACTIVE {state.vars.def_mode_from=}", msg=state.positions)
            return True
        else:
            #state.ilog(e=f"STANDARD mode ACTIVE {state.vars.def_mode_from=}", msg=state.positions)
            return False
    
    def get_limitka_price():
        def_profit = safe_get(state.vars, "def_profit",state.vars.profit) 
        cena = float(state.avgp)
        #v MYSELL hrajeme i na 3 desetinna cisla - TBD mozna hrat jen na 5ky (0.125, 0.130, 0.135 atp.)
        if is_defensive_mode():
            return price2dec(cena+get_tick(cena,float(def_profit)),3)
        else:
            return price2dec(cena+get_tick(cena,float(state.vars.profit)),3)
        
    def consolidation():
        ##CONSOLIDATION PART - moved here, musí být před nákupem, jinak to dělalo nepořádek v pendingbuys
        #docasne zkusime konzolidovat i kdyz neni vylozeno (aby se srovnala limitka ve vsech situacich)
        if state.vars.jevylozeno == 1 or 1==1:
            ##CONSOLIDATION PART kazdy Nty bar dle nastaveni
            if int(data["index"])%int(state.vars.consolidation_bar_count) == 0:
                print("***CONSOLIDATION ENTRY***")
                state.ilog(e="CONSOLIDATION ENTRY ***")

                orderlist = state.interface.get_open_orders(symbol=state.symbol, side=None)
                #pro jistotu jeste dotahneme aktualni pozice
                state.avgp, state.positions = state.interface.pos()            

                #print(orderlist)
                pendingbuys_new = {}
                #zaciname s cistym stitem
                state.vars.limitka = None
                state.vars.limitka_price = None
                for o in orderlist:
                    if o.side == OrderSide.BUY and o.order_type == OrderType.LIMIT:
                        pendingbuys_new[str(o.id)]=float(o.limit_price)

                if pendingbuys_new != state.vars.pendingbuys:
                    state.ilog(e="Rozdilna PB prepsana", pb_new=pendingbuys_new, pb_old = state.vars.pendingbuys)
                    print("ROZDILNA PENDINGBUYS přepsána")
                    print("OLD",state.vars.pendingbuys)
                    state.vars.pendingbuys = unpackb(packb(pendingbuys_new))
                    print("NEW", state.vars.pendingbuys)
                else:
                    print("PENDINGBUYS sedí - necháváme", state.vars.pendingbuys)
                    state.ilog(e="PB sedi nechavame", pb_new=pendingbuys_new, pb_old = state.vars.pendingbuys)
                print("OLD jevylozeno", state.vars.jevylozeno)
                if len(state.vars.pendingbuys) > 0:
                    state.vars.jevylozeno = 1
                else:
                    state.vars.jevylozeno = 0
                print("NEW jevylozeno", state.vars.jevylozeno)
                state.ilog(e="Nove jevylozeno", msg=state.vars.jevylozeno)

                print("***CONSOLIDATION EXIT***")
                state.ilog(e="CONSOLIDATION EXIT ***")
            else:
                state.ilog(e="No time for consolidation", msg=data["index"])
                print("no time for consolidation", data["index"])
    #mozna presunout o level vys
    def vyloz():
        ##prvni se vyklada na aktualni cenu, další jdou podle krivky, nula v krivce zvyšuje množství pro následující iteraci
        #curve = [0.01, 0.01, 0, 0, 0.01, 0, 0, 0, 0.02, 0, 0, 0, 0.03, 0,0,0,0,0, 0.02, 0,0,0,0,0,0, 0.02]
        curve = state.vars.curve
        ##defenzivni krivka pro 
        curve_def = state.vars.curve_def
        #vykladani po 5ti kusech, když zbývají 2 a méně, tak děláme nový výklad
        vykladka = state.vars.vykladka
        #kolik muzu max vylozit
        kolikmuzu = int((int(state.vars.maxpozic) - int(state.positions))/int(state.vars.chunk))
        akt_pozic = int(state.positions)
        max_pozic = int(state.vars.maxpozic)

        if akt_pozic >= max_pozic:
            state.ilog(e="MAX pozic reached, cannot vyklad")
            return
        
        #mame polovinu a vic vylozeno, pouzivame defenzicni krivku
        if is_defensive_mode():
            state.ilog(e="DEF: Pouzivame defenzivni krivku", akt_pozic=akt_pozic, max_pozic=max_pozic, curve_def=curve_def)
            curve = curve_def
            #zaroven docasne menime ticks2reset na defenzivni 0.06
            state.vars.ticks2reset = 0.06
            state.ilog(e="DEF: Menime tick2reset na 0.06", ticks2reset=state.vars.ticks2reset, ticks2reset_backup=state.vars.ticks2reset_backup)
        else:
            #vracime zpet, pokud bylo zmeneno
            if state.vars.ticks2reset != state.vars.ticks2reset_backup:
                state.vars.ticks2reset = state.vars.ticks2reset_backup
                state.ilog(e="DEF: Menime tick2reset zpet na"+str(state.vars.ticks2reset), ticks2reset=state.vars.ticks2reset, ticks2reset_backup=state.vars.ticks2reset_backup)

        if kolikmuzu < vykladka: vykladka = kolikmuzu

        if len(curve) < vykladka:
            vykladka = len(curve)
        qty = int(state.vars.chunk)
        last_price = price2dec(state.interface.get_last_price(state.symbol))
        #profit = float(state.vars.profit)
        price = last_price
        state.ilog(e="BUY Vykladame", msg=f"first price {price=} {vykladka=}", curve=curve, ema=state.indicators.ema[-1], trend=state.vars.Trend, price=price, vykladka=vykladka)
        ##prvni se vyklada na aktualni cenu, další jdou podle krivky, nula v krivce zvyšuje množství pro následující iteraci
        
        ##VAR - na zaklade conf. muzeme jako prvni posilat MARKET order
        if safe_get(state.vars, "first_buy_market") == True:
            #pri defenzivnim rezimu pouzivame vzdy LIMIT order
            if is_defensive_mode():
                state.ilog(e="DEF mode on, odesilame jako prvni limitku")
                state.buy_l(price=price, size=qty)
            else:
                state.ilog(e="Posilame jako prvni MARKET order")
                state.buy(size=qty)
        else:
            state.buy_l(price=price, size=qty)
        print("prvni limitka na aktuální cenu. Další podle křivky", price, qty)
        for i in range(0,vykladka-1):
            price = price2dec(float(price - get_tick(price, curve[i])))
            if price == last_price:
                qty = qty + int(state.vars.chunk)
            else:
                state.buy_l(price=price, size=qty)
                #print(i,"BUY limitka - delta",curve[i]," cena:", price, "mnozstvi:", qty)
                qty = int(state.vars.chunk)
            last_price = price
        state.vars.blockbuy = 1
        state.vars.jevylozeno = 1
        state.vars.last_buysignal_index = data['index']

    def eval_sell():
        """"
        TBD
        Když je RSI nahoře tak neprodávat, dokud 1) RSI neprestane stoupat 2)nedosahne to nad im not greedy limit
        """
        ##mame pozice
        ##aktualni cena je vetsi nebo rovna cene limitky
        #muzeme zde jet i na pulcenty
        curr_price = float(data['close'])
        state.ilog(e="Eval SELL", price=curr_price, pos=state.positions, avgp=state.avgp, sell_in_progress=state.vars.sell_in_progress)
        if int(state.positions) > 0 and float(state.avgp)>0 and state.vars.sell_in_progress is False:
            goal_price = get_limitka_price()
            state.ilog(e=f"Goal price {goal_price}")
            if curr_price>=goal_price:

                #TODO cekat az slope prestane intenzivn erust, necekat az na klesani
                #TODO mozna cekat na nejaky signal RSI
                #TODO pripadne pokud dosahne TGTBB prodat ihned

                #OPTIMALIZACE pri stoupajícím angle
                if sell_protection_enabled() is False:
                    state.interface.sell(size=state.positions)
                    state.vars.sell_in_progress = True
                    state.ilog(e=f"market SELL was sent {curr_price=}", positions=state.positions, avgp=state.avgp, sellinprogress=state.vars.sell_in_progress)

    def populate_ema_indicator():
        #BAR EMA INDICATOR - 
        #plnime MAcko - nyni posilame jen N poslednich hodnot
        #zaroven osetrujeme pripady, kdy je malo dat a ukladame nulu
        try:
            ma = int(state.vars.MA)
            #poslednich ma hodnot
            source = state.bars.close[-ma:] #state.bars.vwap
            ema_value = ema(source, ma)

            ##pokus MACKO zakrouhlit na tri desetina a petku
            state.indicators.ema[-1]=round2five(ema_value[-1])
            ##state.indicators.ema[-1]=trunc(ema_value[-1],3)
            #state.ilog(e=f"EMA {state.indicators.ema[-1]}", ema_last=state.indicators.ema[-6:])
        except Exception as e:
            state.ilog(e="EMA nechavame  0", message=str(e)+format_exc())
            #state.indicators.ema[-1]=(0)
            #evaluate buy signal
            #consolidation

    def populate_slope_indicator():
        #SLOPE INDICATOR
        #úhel stoupání a klesání vyjádřený mezi -1 až 1
        #pravý bod přímky je aktuální cena, levý je průměr X(lookback offset) starších hodnot od slope_lookback.
        #obsahuje statický indikátor (angle) pro vizualizaci
        try:
            slope = 99
            slope_lookback = int(state.vars.slope_lookback)
            minimum_slope = float(state.vars.minimum_slope)
            lookback_offset = int(state.vars.lookback_offset)

            if len(state.bars.close) > (slope_lookback + lookback_offset):
                array_od = slope_lookback + lookback_offset
                array_do = slope_lookback
                lookbackprice_array = state.bars.vwap[-array_od:-array_do]
                #obycejný prumer hodnot
                lookbackprice = round(sum(lookbackprice_array)/lookback_offset,3)

                #výpočet úhlu - a jeho normalizace
                slope = ((state.bars.close[-1] - lookbackprice)/lookbackprice)*100
                slope = round(slope, 4)
                state.indicators.slope[-1]=slope
    
                #angle je ze slope
                state.statinds.angle = dict(time=state.bars.time[-1], price=state.bars.close[-1], lookbacktime=state.bars.time[-slope_lookback], lookbackprice=lookbackprice, minimum_slope=minimum_slope, maximum_slope=safe_get(state.vars, "bigwave_slope_above",0.20))
    
                #slope MA vyrovna vykyvy ve slope, dále pracujeme se slopeMA
                slope_MA_length = 5
                source = state.indicators.slope[-slope_MA_length:]
                slopeMAseries = ema(source, slope_MA_length) #state.bars.vwap
                slopeMA = slopeMAseries[-1]
                state.indicators.slopeMA[-1]=slopeMA

                state.ilog(e=f"{slope=} {slopeMA=}", msg=f"{lookbackprice=}", lookbackoffset=lookback_offset, minimum_slope=minimum_slope, last_slopes=state.indicators.slope[-10:], last_slopesMA=state.indicators.slopeMA[-10:])

                #dale pracujeme s timto MAckovanym slope
                slope = slopeMA         
            else:
                #pokud plnime historii musime ji plnit od zacatku, vsehcny idenitifkatory maji spolecny time
                #kvuli spravnemu zobrazovani na gui
                #state.indicators.slopeMA[-1]=0
                #state.indicators.slopeMA.append(0)
                state.ilog(e="Slope - not enough data", slope_lookback=slope_lookback, slope=state.indicators.slope, slopeMA=state.indicators.slopeMA)
        except Exception as e:
            print("Exception in NEXT Slope Indicator section", str(e))
            state.ilog(e="EXCEPTION", msg="Exception in Slope Indicator section" + str(e) + format_exc())

    def populate_rsi_indicator():
            #RSI14 INDICATOR
        try:
            rsi_length = int(safe_get(state.vars, "rsi_length",14))
            source = state.bars.close #[-rsi_length:] #state.bars.vwap
            rsi_res = rsi(source, rsi_length)
            rsi_value = trunc(rsi_res[-1],3)
            state.indicators.RSI14[-1]=rsi_value
            #state.ilog(e=f"RSI {rsi_length=} {rsi_value=} {rsi_dont_buy=} {rsi_buy_signal=}", rsi_indicator=state.indicators.RSI14[-5:])
        except Exception as e:
            state.ilog(e=f"RSI {rsi_length=} necháváme 0", message=str(e)+format_exc())
            #state.indicators.RSI14[-1]=0

    def populate_cbar_rsi_indicator():
            #CBAR RSI indicator
        try:
            crsi_length = int(safe_get(state.vars, "crsi_length",14))
            source = state.cbar_indicators.tick_price #[-rsi_length:] #state.bars.vwap
            crsi_res = rsi(source, crsi_length)
            crsi_value = trunc(crsi_res[-1],3)
            state.cbar_indicators.CRSI[-1]=crsi_value
            #state.ilog(e=f"RSI {rsi_length=} {rsi_value=} {rsi_dont_buy=} {rsi_buy_signal=}", rsi_indicator=state.indicators.RSI14[-5:])
        except Exception as e:
            state.ilog(e=f"CRSI {crsi_length=} necháváme 0", message=str(e)+format_exc())
            #state.indicators.RSI14[-1]=0

    def slope_too_low():
        return state.indicators.slopeMA[-1] < float(state.vars.minimum_slope)
    
    def slope_too_high():
        return state.indicators.slopeMA[-1] > float(safe_get(state.vars, "bigwave_slope_above",0.20))

    #resetujeme, kdyz 1) je aktivni buy protection 2) kdyz to ujede
    #TODO mozna tick2reset spoustet jednou za X opakovani
    def pendingbuys_optimalization():
        if len(state.vars.pendingbuys)>0:
            if buy_protection_enabled():
                #state.ilog(e="PENDINGBUYS reset", message=inspect.currentframe().f_code.co_name)
                res = asyncio.run(state.cancel_pending_buys())
                state.ilog(e="CANCEL pendingbuyes", pb=state.vars.pendingbuys, res=res)
            else:
                #pokud mame vylozeno a cena je vetsi nez tick2reset 
                maxprice = max(state.vars.pendingbuys.values())
                if state.interface.get_last_price(state.symbol) > float(maxprice) + get_tick(maxprice, float(state.vars.ticks2reset)):
                    res = asyncio.run(state.cancel_pending_buys())
                    state.ilog(e=f"UJELO to. Rusime PB", msg=f"{state.vars.ticks2reset=}", pb=state.vars.pendingbuys)

            #PENDING BUYS SPENT - PART
            #pokud mame vylozeno a pendingbuys se vyklepou a 
            # 1 vykladame idned znovu
                # vyloz()
            # 2 nebo - počkat zase na signál a pokračovat dál  
                # state.vars.blockbuy = 0
                # state.vars.jevylozeno = 0
            # 3 nebo - počkat na signál s enablovaným lastbuy indexem (tzn. počká nutně ještě pár barů)   
            #podle BT vyhodnejsi vylozit ihned
            if len(state.vars.pendingbuys) == 0:
                state.vars.blockbuy = 0
                state.vars.jevylozeno = 0
                state.ilog(e="PB prazdne nastavujeme: neni vylozeno", jevylozeno=state.vars.jevylozeno)

    ##kdy nesmí být žádné nákupní objednávky - zruší se
    def buy_protection_enabled():
        dont_buy_when = dict(AND=dict(), OR=dict())
        ##add conditions here
        dont_buy_when['rsi_too_high'] = state.indicators.RSI14[-1] > safe_get(state.vars, "rsi_dont_buy_above",50)
        dont_buy_when['slope_too_low'] = slope_too_low()

        result, cond_met = eval_cond_dict(dont_buy_when)
        if result:
            state.ilog(e=f"BUY_PROTECTION {cond_met}")
        return result

    def sell_protection_enabled():
        dont_sell_when = dict(AND=dict(), OR=dict())
        ##add conditions here

        #IDENTIFIKOVAce rustoveho MOMENTA - pokud je momentum, tak prodávat později
        
        #pokud je slope too high, pak prodavame jakmile slopeMA zacne klesat, napr. 4MA (TODO 3)

        #toto docasne pryc dont_sell_when['slope_too_high'] = slope_too_high() and not isfalling(state.indicators.slopeMA,4)
        dont_sell_when['AND']['slopeMA_rising'] = isrising(state.indicators.slopeMA,2)
        dont_sell_when['AND']['rsi_not_falling'] = not isfalling(state.indicators.RSI14,3)
        #dont_sell_when['rsi_dont_buy'] = state.indicators.RSI14[-1] > safe_get(state.vars, "rsi_dont_buy_above",50)
 
        result, conditions_met = eval_cond_dict(dont_sell_when)
        if result:
            state.ilog(e=f"SELL_PROTECTION {conditions_met} enabled")
        return result

    #preconditions and conditions of BUY SIGNAL
    def buy_conditions_met():
        #preconditions
        dont_buy_when = dict(AND=dict(), OR=dict())

        
        if safe_get(state.vars, "buy_only_on_confirmed",True):
            dont_buy_when['bar_not_confirmed'] = (data['confirmed'] == 0)
        #od posledniho vylozeni musi ubehnout N baru
        dont_buy_when['last_buy_offset_too_soon'] =  data['index'] < (state.vars.last_buysignal_index + safe_get(state.vars, "lastbuy_offset",3))
        dont_buy_when['blockbuy_active'] = (state.vars.blockbuy == 1)
        dont_buy_when['jevylozeno_active'] = (state.vars.jevylozeno == 1)
        dont_buy_when['rsi_too_high'] = state.indicators.RSI14[-1] > safe_get(state.vars, "rsi_dont_buy_above",50)
        dont_buy_when['slope_too_low'] = slope_too_low()
        dont_buy_when['open_rush'] = is_open_rush(datetime.fromtimestamp(data['updated']).astimezone(zoneNY), safe_get(state.vars, "open_rush",0))
        dont_buy_when['close_rush'] = is_close_rush(datetime.fromtimestamp(data['updated']).astimezone(zoneNY), safe_get(state.vars, "close_rush",0))
        dont_buy_when['rsi_is_zero'] = (state.indicators.RSI14[-1] == 0)

        #testing preconditions
        result, cond_met = eval_cond_dict(dont_buy_when)
        if result:
            state.ilog(e=f"BUY precondition not met {cond_met}")
            return False

        #conditions - bud samostatne nebo v groupe - ty musi platit dohromady
        buy_cond = dict(AND=dict(), OR=dict())
        ##add buy conditions here
        #cond groups ["AND"]
        #cond groups ["OR"]
        #no cond group - takes first
        #TEST BUY SIGNALu z cbartick_price - 3klesave za sebou
        #buy_cond['tick_price_falling_trend'] = isfalling(state.cbar_indicators.tick_price,state.vars.Trend)

        #slopeMA jde dolu, rsi jde nahoru
        #buy mame kazdy potvrzeny, tzn. rsi falling muze byt jen 2
        
        #buy_cond['AND']['slopeMA_falling'] = isfalling(state.indicators.slopeMA,3)
        #buy_cond['AND']['rsi_is_rising'] = isrising(state.indicators.RSI14,2)
        #buy_cond["AND"]["rsi_buy_signal_below"] = state.indicators.RSI14[-1] < safe_get(state.vars, "rsi_buy_signal_below",40)

        #puvodni buy conditiony RSI pod + EMA klesajici
        #buy_cond["AND"]["rsi_buy_signal_below"] = state.indicators.RSI14[-1] < safe_get(state.vars, "rsi_buy_signal_below",40)
        #buy_cond["AND"]["ema_trend_is_falling"] = isfalling(state.indicators.ema,state.vars.Trend)

        #pouze RSI nizke a RSI klesa
        buy_cond["AND"]["rsi_buy_signal_below"] = state.indicators.RSI14[-1] < safe_get(state.vars, "rsi_buy_signal_below",40)
        buy_cond["AND"]["rsi_is_falling"] = isfalling(state.indicators.RSI14,state.vars.Trend)
        
        #buy_cond['crsi_below_crsi_buy_limit'] = state.cbar_indicators.CRSI[-1] < safe_get(state.vars, "crsi_buy_signal_below",30)
       
        #slopME klesa a RSI začalo stoupat
        # buy_cond["AND"]["rsi_is_rising2"] = isrising(state.indicators.RSI14,2)
        # buy_cond['AND']['slopeMA_falling_Trend'] = isfalling(state.indicators.slopeMA,state.vars.Trend)
        # buy_cond["AND"]["rsi_buy_signal_below"] = state.indicators.RSI14[-1] < safe_get(state.vars, "rsi_buy_signal_below",40)


        #zkusit jako doplnkovy BUY SIGNAL 3 klesavy cbar RSI pripadne TICK PRICE

        result, conditions_met = eval_cond_dict(buy_cond)
        if result:
            state.ilog(e=f"BUY SIGNAL {conditions_met}")
        return result

    def eval_buy():
        if buy_conditions_met():
                vyloz()

    def populate_cbar_tick_price_indicator():
        try:
            #pokud v potvrzovacím baru nebyly zmeny, nechavam puvodni hodnoty
            # if tick_delta_volume == 0:
            #     state.indicators.tick_price[-1] = state.indicators.tick_price[-2]
            #     state.indicators.tick_volume[-1] = state.indicators.tick_volume[-2]
            # else:

            tick_price = round2five(data['close'])
            tick_delta_volume = data['volume'] - state.vars.last_tick_volume

            #docasne dame pryc volume deltu a davame absolutni cislo
            state.cbar_indicators.tick_price[-1] = tick_price
            state.cbar_indicators.tick_volume[-1] = tick_delta_volume
        except:
            pass

        state.ilog(e=f"TICK PRICE {tick_price} VOLUME {tick_delta_volume} {conf_bar=}", prev_price=state.vars.last_tick_price, prev_volume=state.vars.last_tick_volume)

        state.vars.last_tick_price = tick_price
        state.vars.last_tick_volume = data['volume']

    def get_last_ind_vals():
        last_ind_vals = {}
        #print(state.indicators.items())
        for key in state.indicators:
            if key != 'time':
                last_ind_vals[key] = state.indicators[key][-5:]
        
        for key in state.cbar_indicators:
            if key != 'time':
                last_ind_vals[key] = state.cbar_indicators[key][-5:]    
        return last_ind_vals

    conf_bar = data['confirmed']
    last_update_delta = round((float(data['updated']) - state.vars.last_update_time),6) if state.vars.last_update_time != 0 else 0
    state.vars.last_update_time = float(data['updated'])
    state.ilog(e=f"---{data['index']}-{conf_bar}--delta:{last_update_delta}")

    #kroky pro CONFIRMED BAR only
    if conf_bar == 1:
        #logika pouze pro potvrzeny bar
        state.ilog(e="BAR potvrzeny")


        #pri potvrzem CBARu nulujeme counter volume pro tick based indicator
        state.vars.last_tick_volume = 0
        state.vars.next_new = 1

    #kroky pro CONTINOUS TICKS only
    else:
        #CBAR INDICATOR pro tick price a deltu VOLUME
        populate_cbar_tick_price_indicator()
        populate_cbar_rsi_indicator()

    #SPOLECNA LOGIKA - bar indikatory muzeme populovat kazdy tick (dobre pro RT GUI), ale uklada se stejne az pri confirmu
    

    populate_ema_indicator()
    populate_slope_indicator()
    populate_rsi_indicator()
    eval_sell()
    consolidation()

    #HLAVNI ITERACNI LOG JESTE PRED AKCI - obsahuje aktualni hodnoty vetsiny parametru
    lp = state.interface.get_last_price(symbol=state.symbol)
    state.ilog(e="ENTRY", msg=f"LP:{lp} P:{state.positions}/{round(float(state.avgp),3)} profit:{round(float(state.profit),2)} Trades:{len(state.tradeList)} DEF:{str(is_defensive_mode())}", last_price=lp, data=data, stratvars=state.vars)
    state.ilog(e="Indikatory", msg=str(get_last_ind_vals()))

    eval_buy()
    pendingbuys_optimalization()

def init(state: StrategyState):
    #place to declare new vars
    print("INIT v main",state.name)

    state.vars['sell_in_progress'] = False
    state.vars.last_tick_price = 0
    state.vars.last_tick_volume = 0
    state.vars.next_new = 0
    state.vars.last_buysignal_index = 0
    state.vars.last_update_time = 0
    #state.cbar_indicators['ivwap'] = []
    state.cbar_indicators['tick_price'] = []
    state.cbar_indicators['tick_volume'] = []
    state.cbar_indicators['CRSI'] = []
    state.indicators['ema'] = []
    state.indicators['slope'] = []
    state.indicators['slopeMA'] = []
    state.indicators['RSI14'] = []
    #static indicators - those not series based
    state.statinds['angle'] = dict(minimum_slope=state.vars["minimum_slope"], maximum_slope=safe_get(state.vars, "bigwave_slope_above",0.20))
    state.vars["ticks2reset_backup"] = state.vars.ticks2reset

def main():
    name = os.path.basename(__file__)
    se = Event()
    pe = Event()
    s = StrategyOrderLimitVykladaciNormalizedMYSELL(name = name, symbol = "BAC", account=Account.ACCOUNT1, next=next, init=init, stratvars=stratvars, open_rush=10, close_rush=0, pe=pe, se=se, ilog_save=True)
    s.set_mode(mode = Mode.BT,
               debug = False,
               start = datetime(2023, 4, 14, 10, 42, 0, 0, tzinfo=zoneNY),
               end =   datetime(2023, 4, 14, 14, 35, 0, 0, tzinfo=zoneNY),
               cash=100000)

    #na sekundovem baru nezaokrouhlovat MAcko
    s.add_data(symbol="BAC",rectype=RecordType.BAR,timeframe=2,minsize=100,update_ltp=True,align=StartBarAlign.ROUND,mintick=0, exthours=False)
    #s.add_data(symbol="C",rectype=RecordType.BAR,timeframe=1,filters=None,update_ltp=True,align=StartBarAlign.ROUND,mintick=0)

    s.start()
    print("zastavujeme")

if __name__ == "__main__":
    main()




 