#!/home/hoogca/virtualenv/bri/3.7/bin/python
###!/home/debian/miniconda3/bin/python3
#print("Incl test")

import sys, os, math
import xml.etree.ElementTree as ET
from pathlib import Path
from websocket import create_connection   # pip install websocket-client
### source /home/hoogca/virtualenv/bri/3.7/bin/activate && pip install websocket-client
import json
import random
import string
import re
import csv
from datetime import datetime
import time
now=time.time() 
import numpy as np
import pandas as pd
from numpy import inf
import matplotlib.pyplot as plt
pd.options.mode.chained_assignment = None 
import struct
import sqlite3
from datetime import datetime as dt, timedelta as tdelta

global interval, quoteInternal, Records, quote, interval2, dir
global nRecords,idx,rows,HighestHigh,LowestLow,nRow,LastClose,LastDT

def include(filename):
    #hprint(filename)
    if os.path.exists(filename):
        #hprint("2")
        exec(compile(source=open(filename).read(), filename=filename, mode='exec'))


def hprint(text):
   print(f"{text}<br>\n")


def filter_raw_message(text):
    try:
        found1 = re.search('"m":"(.+?)",', text).group(1)
        found2 = re.search('"p":(.+?"}"])}', text).group(1)
        print(found1)
        print(found2)
        return found1, found2
    except AttributeError:
        print("error")


def generateSession():
    stringLength = 12
    letters = string.ascii_lowercase
    random_string = ''.join(random.choice(letters) for i in range(stringLength))
    return "qs_" + random_string


def generateChartSession():
    stringLength = 12
    letters = string.ascii_lowercase
    random_string = ''.join(random.choice(letters) for i in range(stringLength))
    return "cs_" + random_string


def prependHeader(st):
    return "~m~" + str(len(st)) + "~m~" + st


def constructMessage(func, paramList):
    # json_mylist = json.dumps(mylist, separators=(',', ':'))
    return json.dumps({
        "m": func,
        "p": paramList
    }, separators=(',', ':'))


def createMessage(func, paramList):
    return prependHeader(constructMessage(func, paramList))


def sendRawMessage(ws, message):
    ws.send(prependHeader(message))


def sendMessage(ws, func, args):
    #ws.send(createMessage(func, args))
    j=json.dumps({
        "m": func,
        "p": args
    }, separators=(',', ':'))
    j="~m~" + str(len(j)) + "~m~" + j
    ws.send(j)


def extractData(a):
    out = re.search('"s":\[(.+?)\}\]', a).group(1)
    x = out.split(',{\"')

    with open('data_file.csv', mode='w', newline='') as data_file:
        writer = csv.writer(data_file, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)

        writer.writerow(['index', 'date', 'open', 'high', 'low', 'close', 'volume'])

        for xi in x:
            xi = re.split('\[|:|,|\]', xi)
            print(xi)
            ind = int(xi[1])
            ts = datetime.fromtimestamp(float(xi[4])).strftime("%Y/%m/%d, %H:%M:%S")
            writer.writerow([ind, ts, float(xi[5]), float(xi[6]), float(xi[7]), float(xi[8]), float(xi[9])])

headers = json.dumps({
    'Connection': 'upgrade',
    'Host': 'data.tradingview.com',
    'Origin': 'https://data.tradingview.com',
    'Cache-Control': 'no-cache',
    'Upgrade': 'websocket',
    'Sec-WebSocket-Extensions': 'permessage-deflate; client_max_window_bits',
    # 'Sec-WebSocket-Key': '2C08Ri6FwFQw2p4198F/TA==',
    # 'Sec-WebSocket-Version': '13',
    'User-Agent': 'User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36 Edg/83.0.478.56',
    'Pragma': 'no-cache',
    'Upgrade': 'websocket'
})

ws = create_connection('wss://data.tradingview.com/socket.io/websocket', headers=headers)


session = generateSession()
#print("session generated {}".format(session))

chart_session = generateChartSession()
#print("chart_session generated {}".format(chart_session))

sendMessage(ws, "set_auth_token", ["unauthorized_user_token"])
sendMessage(ws, "chart_create_session", [chart_session, ""])
sendMessage(ws, "quote_create_session", [session])
sendMessage(ws, "resolve_symbol", [chart_session, "symbol_1","={\"symbol\":\"%s\",\"adjustment\":\"splits\",\"session\":\"extended\"}"%quoteInternal])
sendMessage(ws, "create_series", [chart_session, "s1", "s1", "symbol_1", "%s"%interval, 1000])

series_loading=""
timescale_update=""
while True:
    try:
        result = ws.recv()
        if (result.find("series_loading") > 0): series_loading=result
        if(result.find("timescale_update")>0):
            timescale_update=result
            #print(result)
            #extractData(result)
            break;
    except Exception as e:
        print(e)
        break

def excel_date(datetime, offset=0):
    """convert date&time with offset in hours to excel format for scid"""
    delta = datetime - dt(1899, 12, 30) + tdelta(hours=offset)
    return delta.days + delta.seconds / 86400

def python_date(exceldt, offset=0):
    """convert date&time with offset in hours to python format"""
    excel_as_delta = tdelta(days=exceldt//1) + tdelta(seconds=exceldt%1*86400)
    return dt(1899, 12, 30) + excel_as_delta + tdelta(hours=offset)

FILES_OUT = "C:\\SierraChart\\SierraChartTransActMA\\Data\\"

MaxIndex=int((24*60)/int(interval2))
SumVolumeByTime = [0] * MaxIndex
nSumVolumeByTime = [0] * MaxIndex
try:
    data = re.search('"s":\[(.+?)\}\]', timescale_update).group(1)
except:
    hprint(f"{quote} Not found.")
    sys.exit() 
lines = data.split(',{\"')

LastLine=lines[-1]
fields = re.split('\[|:|,|\]', LastLine)
LastUnixDate=int(float(fields[4]))
LastExcelDate=excel_date(datetime.fromtimestamp(LastUnixDate), 4)
#print(LastLine)

# Exponential moving average ...
def EMA(PriceToday,EMAyesterday,nPeriod):
    return PriceToday*(2/(nPeriod+1))+EMAyesterday*(1-(2/(nPeriod+1)))

nRecords=0
prevAvgVolumePerTime=0
prevVolume = 0
rows=[]
HighestHigh=-10000000
LowestLow=10000000
nRow=0
LastClose=0
LastDT=""
prevClose=0
prevLow=0
prevHigh=0
global GlobalSpreadAvg, GlobalGainAvg
GlobalSpreadAvg=0
SpreadTot=0
nSpreadTot=0
GlobalGainAvg=0
GainTot=0
nGainTot=0
for line in lines:
    line = line.strip()
    if line:  # not empty
        #hprint(line)
        fields = re.split('\[|:|,|\]', line)
        unixDate=int(float(fields[4]))
        day=datetime.fromtimestamp(unixDate).day
        month=datetime.fromtimestamp(unixDate).month
        year=datetime.fromtimestamp(unixDate).year
        hour=datetime.fromtimestamp(unixDate).hour
        minute = datetime.fromtimestamp(unixDate).minute
        idx=int(((hour*60)+minute)/int(interval2))
        excelDate=excel_date(datetime.fromtimestamp(unixDate), 4)
        openX=float(fields[5])
        high=float(fields[6])
        low=float(fields[7])
        close=float(fields[8])
        
        if(nRow>1):
            if(prevClose > high):
                high=prevClose
                openX=prevClose
            elif(prevClose < low):
                low=prevClose
                openX=prevClose
			
            if(openX > prevHigh):
                openX=prevHigh
            elif(openX < prevLow):
                openX=prevLow
                
        #if(low<=0): low[nRow]=low[nRow]
        if(low<=0): low=prevLow
        
        sprd=high-low
        if sprd!=0:
            SpreadTot=SpreadTot+sprd
            nSpreadTot=nSpreadTot+1
            
        gn=close-openX
        if gn!=0:
            GainTot=GainTot+abs(gn)
            nGainTot=nGainTot+1
        
        days_difference = (LastUnixDate - unixDate)/(60*60*24)
        #print(days_difference)
        volume=int(float(fields[9]))
        
        if high>HighestHigh: HighestHigh=high
        if low<LowestLow: LowestLow=low
        
        if volume>0 and days_difference<numDaysBack:
            SumVolumeByTime[idx]=SumVolumeByTime[idx]+volume
            nSumVolumeByTime[idx] = nSumVolumeByTime[idx] + 1
            
        #hprint(f"{day}-{month}-{year} | {hour}:{minute} | {index} | {openX} | {high} | {low} | {close} | {volume} | {FWDvolMA20} | {FWDvolMA10} | {FWDvolMA5} | <b>{VolumePerTick}</b> | <b>{VolumePerTickMA}</b> | {EffortResult} | {EffortResultAbsMA}")
        #hprint(f"{day}-{month}-{year} | {hour}:{minute} | {close} | {pCloseMA5} | {pEMA1} | {pEMA2} | {pZZMA}")
        
        rows.append([year,month,day,hour,minute,idx,openX,high,low,close,volume])
        LastClose=close
        nRecords=nRecords+1
        LastDT=f"{hour}:{minute}"
        nRow=nRow+1
        #print(f"{hour} | {minute} | {index} | {unixDate} | {excelDate}")
        #wt = struct.pack('d4f4I', excel_date(datetime.fromtimestamp(unixDate),4), float(fields[5]), float(fields[6]), float(fields[7]), float(fields[8]), 0, int(float(fields[9])), 0, 0)
        #scidfile.write(wt)
        prevClose=close
        prevLow=low
        prevHigh=high

Records = pd.DataFrame(rows, columns=['year','month','day','hour','minute','idx','openX','high','low','close','volume'])

if nSpreadTot>0:
    GlobalSpreadAvg=SpreadTot/nSpreadTot
if nGainTot>0:
    GlobalGainAvg=GainTot/nGainTot

global iHigh,iLow,iClose,iOpen,iVolume,iYear,iMonth,iDay,iHour,iMinute
iHigh=Records['high'] 
iLow=Records['low']
iClose=Records['close']
iOpen=Records['openX']
iVolume=Records['volume']
iYear=Records['year'] 
iMonth=Records['month'] 
iDay=Records['day'] 
iHour=Records['hour'] 
iMinute=Records['minute'] 
idx=Records['idx']

global iZZMA5,iZZMA15,iVolMA,iVolumePerTick,iVolumePerTickMA,iSpread,iSpreadMA,iPrevClose,iGain,iGainMA
global vMAperiod
vMAperiod=20

Records['prevClose']=Records['close'].shift(1)
iPrevClose=Records['prevClose']

Records['Ema1'] = iClose.ewm(span=5, min_periods=1).mean()
Records['Ema2'] = Records['Ema1'].ewm(span=5, min_periods=1).mean() 
Records['pZZMA5'] = Records['Ema1']+(Records['Ema1']-Records['Ema2'])
#Records['pZZMA5slope'] = 1/(Records['pZZMA5']-Records['pZZMA5'].shift(1))
Records['pcChange_pZZMA5'] = ((Records['pZZMA5']-Records['pZZMA5'].shift(1))*100.0)/(HighestHigh-LowestLow)

#Records['highMA'] = iHigh.ewm(span=10, min_periods=1).mean()
#Records['pcChange_highMA'] = ((Records['highMA']-Records['highMA'].shift(1))*100.0)/(HighestHigh-LowestLow)

#Records['lowMA'] = iLow.ewm(span=10, min_periods=1).mean()
#Records['pcChange_lowMA'] = ((Records['lowMA']-Records['lowMA'].shift(1))*100.0)/(HighestHigh-LowestLow)

#Records['closeMA'] = iClose.ewm(span=5, min_periods=1).mean()
#Records['pcChange_closeMA'] = ((Records['closeMA']-Records['closeMA'].shift(1))*100.0)/(HighestHigh-LowestLow)


Records['Ema1']=0; Records['Ema1'] = iHigh.ewm(span=5, min_periods=1).mean()
Records['Ema2']=0; Records['Ema2'] = Records['Ema1'].ewm(span=10, min_periods=1).mean()
Records['hZZMA5'] = Records['Ema1']+(Records['Ema1']-Records['Ema2'])
#Records['hZZMA5'] = Records['hZZMA5'].ewm(span=2, min_periods=1).mean()
Records['slope_hZZMA5'] = ((Records['hZZMA5']-Records['hZZMA5'].shift(1))*100.0)/(HighestHigh-LowestLow)

Records['Ema1']=0; Records['Ema1'] = iLow.ewm(span=5, min_periods=1).mean()
Records['Ema2']=0; Records['Ema2'] = Records['Ema1'].ewm(span=10, min_periods=1).mean()
Records['lZZMA5'] = Records['Ema1']+(Records['Ema1']-Records['Ema2'])
#Records['lZZMA5'] = Records['lZZMA5'].ewm(span=2, min_periods=1).mean() 
Records['slope_lZZMA5'] = ((Records['lZZMA5']-Records['lZZMA5'].shift(1))*100.0)/(HighestHigh-LowestLow)

Records['avgZZMA5']=(Records['hZZMA5']+Records['lZZMA5'])/2.0
Records['avgZZMA5slope']= ((Records['avgZZMA5']-Records['avgZZMA5'].shift(1))*100.0)/(HighestHigh-LowestLow)

#Records['Ema1']=0; Records['pEma1'] = iClose.ewm(span=25, min_periods=1).mean()  
#Records['Ema2']=0; Records['pEma2'] = Records['pEma1'].ewm(span=25, min_periods=1).mean() 
#Records['pZZMA15'] = Records['pEma1']+(Records['pEma1']-Records['pEma2'])
#Records['pcChange_pZZMA15'] = ((Records['pZZMA15']-Records['pZZMA15'].shift(1))*100.0)/(HighestHigh-LowestLow)

Records['PeakHigh']=0
Records['PeakLow']=0
def ClosestPeaksHL(p,m): 
    nPeakHigh=p
    nPeakLow=p
    for z in reversed(range(p-m,p)):
        if z>m:
            if Records['high'][z]>Records['high'][nPeakHigh] and Records['high'][z+1]<=Records['high'][z]: nPeakHigh=z
            if Records['low'][z] <Records['low'][nPeakLow] and Records['low'][z+1]>=Records['low'][z]: nPeakLow=z
            
    if Records['PeakHigh'][nPeakHigh]>0 and Records['high'][Records['PeakHigh'][nPeakHigh]]>Records['high'][nPeakHigh]: nPeakHigh=Records['PeakHigh'][nPeakHigh]
    if Records['PeakLow'][nPeakLow]>0 and Records['low'][Records['PeakLow'][nPeakLow]]<Records['low'][nPeakLow]: nPeakLow=Records['PeakLow'][nPeakLow]
    return nPeakHigh,nPeakLow


Records['direction']="neutral"

def HighestHighWave(b,barsBack): 
    nHighestHigh=b
    HighestHigh=Records['high'][b]
    for z in (range(b-barsBack,b)):#reversed
        if Records['high'][z]>HighestHigh:
            HighestHigh=Records['high'][z]
            nHighestHigh=z
    return nHighestHigh
    
def LowestLowWave(b,barsBack): 
    nLowestLow=b
    LowestLow=Records['low'][b]
    for z in (range(b-barsBack,b)):#reversed
        if Records['low'][z]<LowestLow:
            LowestLow=Records['low'][z]
            nLowestLow=z
    return nLowestLow

Records['MomentumWave']=0
Records['VolumeWave']=0

global slope, peaks, Peaks
slope=0.5
SumVolume=0
nSumVolume=0
SumMomentum=0
nSumMomentum=0
peaks=""
peaksdata = []
nPeaks=0
HighPeaks=[]
LowPeaks=[]
nLastPeak=0
for e in (range(1,nRecords)):#reversed
    
    #Records['PeakHigh'][e],Records['PeakLow'][e]=ClosestPeaksHL(e,5)
    
    if e>2 and e<nRecords-1:
        
        if Records['avgZZMA5slope'][e]>slope and (Records['direction'][e-1]=="dn" or Records['direction'][e-1]=="neutral"): 
            # Peak down move --> up move ...
            Records['direction'][e]="up"
            nLastLowPeak=LowestLowWave(e,e-nLastPeak)
            peaks+=f"L{nLastLowPeak},"
            
            peaksdata.append(["up",nLastLowPeak])
            
            #Peaks['Direction'][nPeaks]="up"
            #Peaks['Start'][nPeaks]=nLastLowPeak
            #Peaks['End'][nPeaks]=e
            #nPeaks=nPeaks+1
            
            for z in range(nLastLowPeak,e+1):
                Records['direction'][z]="up"
            nLastPeak=e
        elif Records['avgZZMA5slope'][e]<-slope and (Records['direction'][e-1]=="up" or Records['direction'][e-1]=="neutral"): 
            # Peak up move --> down move ...
            Records['direction'][e]="dn"
            nLastHighPeak=HighestHighWave(e,e-nLastPeak) 
            peaks+=f"H{nLastHighPeak},"
            
            peaksdata.append(["dn",nLastHighPeak])
            
            #Peaks['Direction'][nPeaks]="dn"
            #Peaks['Start'][nPeaks]=nLastHighPeak
            #Peaks['End'][nPeaks]=e
            #nPeaks=nPeaks+1 
            
            for z in range(nLastHighPeak,e+1): 
                Records['direction'][z]="dn"
            nLastPeak=e
        else:
            Records['direction'][e]=Records['direction'][e-1]

        if e==nRecords-2: Records['direction'][e+1]=Records['direction'][e]

Peaks = pd.DataFrame(peaksdata,columns=['Direction','Start'])
#Peaks['End']=Peaks['Start'].shift(1).astype(int,errors='ignore')
#Peaks.replace([np.inf, -np.inf], 0, inplace=True)
#Peaks.replace([np.nan, -np.nan], 0, inplace=True)
Peaks['End']=0
Peaks['wavelength']=0
AvgWaveLength=0
nAvgWaveLength=0
for p in range(0,len(Peaks)):  
    start=Peaks['Start'][p]
    if p<len(Peaks)-1:
        end=Peaks['Start'][p+1]
    else: end=len(Records)-1
    Peaks['End'][p]=end
    direction=Peaks['Direction'][p]
    if direction=="up":
        wavelength=Records['high'][end]-Records['low'][start]
        Peaks['wavelength'][p]=wavelength
    elif direction=="dn":
        wavelength=-(Records['high'][start]-Records['low'][end])
        Peaks['wavelength'][p]=wavelength
    #hprint(f"{start}..{end} | {direction} | {wavelength}")
    
    if not wavelength==0:
        AvgWaveLength=AvgWaveLength+abs(wavelength)
        nAvgWaveLength=nAvgWaveLength+1

if nAvgWaveLength>0:
    AvgWaveLength=AvgWaveLength/nAvgWaveLength
else: AvgWaveLength=0

global avgMomentumWave, avgVolumeWave, HighestMomentumWave, HighestVolumeWave  
HighestMomentumWave=0
HighestVolumeWave=0 

Peaks['PCwave']=0
Peaks['TakenOut']=0
Peaks['WaveTookOut']=""
for p in range(0,len(Peaks)):
    Peaks['PCwave'][p]=round((Peaks['wavelength'][p]*100)/(AvgWaveLength*2))
    
    FoundLow=0
    FoundHigh=0
    for z in (range(p+1,len(Peaks))): #reversed
        #if p==50: hprint(z)  
        if Peaks['Direction'][p]=="dn" and FoundLow==0: # and Peaks['TakenOut'][z]==0 and Peaks['Direction'][z]=="dn"
            CurrentLow=Records['low'][ Peaks['End'][p] ]
            FutureHigh=Records['high'][ Peaks['Start'][z] ]
            FutureLow=Records['low'][ Peaks['End'][z] ]
            
            #hprint(f"{p} | {z} | {CurrentLow} | {FutureHigh} | {FutureLow}")
            
            if CurrentLow>=FutureLow and CurrentLow<=FutureHigh:
                Peaks['TakenOut'][z]=1
                FoundN=z
                for zn in (range(Peaks['Start'][z],Peaks['End'][z]+1)): #reversed
                    znHigh=Records['high'][zn]
                    znLow=Records['low'][zn]
                    if CurrentLow>=znLow and CurrentLow<=znHigh:
                        FoundN=zn
                        break
                if FoundN!=z:
                    Peaks['WaveTookOut'][p]+=f"{z}|{FoundN},"
                    FoundLow=1
        if Peaks['Direction'][p]=="up" and FoundHigh==0: # and Peaks['TakenOut'][z]==0 and Peaks['Direction'][z]=="dn"
            CurrentHigh=Records['high'][ Peaks['End'][p] ]
            FutureHigh=Records['high'][ Peaks['End'][z] ]
            FutureLow=Records['low'][ Peaks['Start'][z] ]
            
            #hprint(f"{p} | {z} | {CurrentLow} | {FutureHigh} | {FutureLow}")
            
            if CurrentHigh>=FutureLow and CurrentHigh<=FutureHigh:
                Peaks['TakenOut'][z]=1
                FoundN=z
                for zn in (range(Peaks['Start'][z],Peaks['End'][z]+1)): #reversed
                    znHigh=Records['high'][zn]
                    znLow=Records['low'][zn]
                    if CurrentHigh>=znLow and CurrentHigh<=znHigh:
                        FoundN=zn
                        break
                if FoundN!=z:
                    Peaks['WaveTookOut'][p]+=f"{z}|{FoundN},"
                    FoundHigh=1            
        if FoundLow==1 and FoundHigh==1: break
        
    #hprint(f"{Peaks['Start'][p]}..{Peaks['End'][p]} | {Peaks['Direction'][p]} | {Peaks['wavelength'][p]} | {Peaks['PCwave'][p]} | {Peaks['WaveTookOut'][p]}")





#for e in (range(1,nRecords)):
#    if e>2:
#        if Records['direction'][e]==Records['direction'][e-1]:
#            if Records['direction'][e]=="up":
#                Records['MomentumWave'][e]=Records['MomentumWave'][e-1]+Records['slope_hZZMA5'][e]
#                Records['VolumeWave'][e]=Records['VolumeWave'][e-1]+Records['volume'][e]
#            elif Records['direction'][e]=="dn":
#                Records['MomentumWave'][e]=Records['MomentumWave'][e-1]-Records['slope_lZZMA5'][e]
#                Records['VolumeWave'][e]=Records['VolumeWave'][e-1]-Records['volume'][e]
                
            #hprint(f"{Records['direction'][e-1]}|{Records['direction'][e]} {Records['VolumeWave'][e-1]}")
            #SumMomentum=SumMomentum+abs(Records['MomentumWave'][e])
            #nSumMomentum=nSumMomentum+1
            #SumVolume=SumVolume+abs(Records['VolumeWave'][e])
            #nSumVolume=nSumVolume+1 
        
#        if Records['direction'][e]!=Records['direction'][e-1]:
#            if Records['direction'][e]=="up":
#                Records['MomentumWave'][e]=Records['slope_hZZMA5'][e]
#                Records['VolumeWave'][e]=Records['volume'][e]
#            if Records['direction'][e]=="dn":
#                Records['MomentumWave'][e]=Records['slope_lZZMA5'][e]
#                Records['VolumeWave'][e]=Records['volume'][e]
            
            #hprint(f"<b>{Records['direction'][e-1]}|{Records['direction'][e]} {Records['VolumeWave'][e-1]}</b>")
#            SumMomentum=abs(Records['MomentumWave'][e-1])
#            nSumMomentum=nSumMomentum+1
#            SumVolume=abs(Records['VolumeWave'][e-1])
#            nSumVolume=nSumVolume+1
        
#        if abs(Records['MomentumWave'][e])>HighestMomentumWave: HighestMomentumWave=abs(Records['MomentumWave'][e])
#        if abs(Records['VolumeWave'][e])>HighestVolumeWave: HighestVolumeWave=abs(Records['VolumeWave'][e])
        

avgMomentumWave=0  
if nSumMomentum>0:
    avgMomentumWave=SumMomentum/nSumMomentum
    
avgVolumeWave=0
if nSumVolume>0:
    avgVolumeWave=SumVolume/nSumVolume

hprint(f"<b>{avgMomentumWave} | {avgVolumeWave}</b>")

#ax = Records['high'].plot(figsize=(150, 7))
#Records['hZZMA5'].plot(ax=ax)
#Records['low'].plot(ax=ax)
#Records['lZZMA5'].plot(ax=ax)
#Records['avglhZZMA5'].plot(ax=ax)
#plt.savefig(f'{dir}/pZZMA5plot.png')
#print(f"<img src=./pZZMA5plot.png?x={now}>")

Records['spread']=(iHigh-iLow)
Records['spreadMA'] = Records['spread'].ewm(span=10, min_periods=1).mean()
Records['gain']=(iClose-iPrevClose)
Records['gainMA'] = Records['gain'].abs().ewm(span=10, min_periods=1).mean() 

global StrongPriceBars
StrongPriceBars= pd.DataFrame(columns=['Direction','Start'])
StrongPriceBars['TakenOut']=0


#for e in (range(1,nRecords)):



include(f"{dir}/py/incl-directionMap2.py")


sys.exit()
















Records['volMAFWD'] = iVolume.ewm(span=vMAperiod, min_periods=1).mean()



#Records['VolumeWave'] = Records['volume'] 


#hprint(Records['pZZMA15'])

ReverseRecords = pd.DataFrame()
ReverseRecords['volume'] = iVolume[::-1]
ReverseRecords['volMAREV'] = ReverseRecords['volume'].ewm(span=vMAperiod, min_periods=1).mean()
RevRevRecords = pd.DataFrame()
RevRevRecords['volMAREV'] = ReverseRecords['volMAREV'][::-1]
Records['volMAREV'] = RevRevRecords['volMAREV']
Records['volMA']=(Records['volMAFWD']+Records['volMAREV'])/2
Records['VolumePerTick']=iVolume/(iHigh-iLow)
Records['VolumePerTickMA'] = Records['VolumePerTick'].ewm(span=5, min_periods=1).mean()


iZZMA5=Records['pZZMA5'] 
iZZMA15=Records['pZZMA15'] 
iVolMA=Records['volMA'] 
iVolumePerTick=Records['VolumePerTick'] 
iVolumePerTickMA=Records['VolumePerTickMA'] 
iSpread=Records['spread']  
iSpreadMA=Records['spreadMA'] 
iGain=Records['gain']  
iGainMA=Records['gainMA'] 

global iEffortPricePerTick,iEffortVolPerTick,iEffortPrice,iEffortVol

Records['EffortPricePerTick'] =((iVolumePerTick/iVolumePerTickMA)*iSpreadMA) #if ((iVolumePerTick/iVolumePerTickMA)*iSpreadMA)<(iSpread*2) else (iSpread*2)
Records['EffortVolPerTick'] =((iSpread/iSpreadMA)*iVolumePerTickMA)
			
Records['EffortPrice']=((iVolume/iVolMA)*iSpreadMA) #if ((iVolume/iVolMA)*iSpreadMA)<(iSpread*2) else (iSpread*2)
Records['EffortVol']=((iSpread/iSpreadMA)*iVolMA)

iEffortPricePerTick=Records['EffortPricePerTick'] 
iEffortVolPerTick=Records['EffortVolPerTick'] 
iEffortPrice=Records['EffortPrice'] 
iEffortVol=Records['EffortVol'] 

global iVolSpreadHigh,iVolSpreadLow,iVolColor
Records['VolSpreadHigh']=0
Records['VolSpreadLow']=0
Records['VolSpreadHighPerTick']=0
Records['VolSpreadLowPerTick']=0
Records['volColor']="255|255|255"
Records['VolSpreadLowTO']=0
Records['VolSpreadHighTO']=0

iVolSpreadLow=Records['VolSpreadLow'] 
iVolSpreadHigh=Records['VolSpreadHigh'] 
iVolSpreadLowPerTick=Records['VolSpreadLowPerTick'] 
iVolSpreadHighPerTick=Records['VolSpreadHighPerTick'] 
def CheckInfNAN(x,ret):
    if x == float('inf') or x == float('-inf'):
        return ret
    return float(x)

Records.replace([np.inf, -np.inf], 0, inplace=True)
Records.replace([np.nan, -np.nan], 0, inplace=True)

#hprint(iSpreadMA[nRecords-10])
#nRecords-500
global dataOut
dataOut="["
VolumeWave=0
direction="up"
def VolumeColor(v,d):
    if d=="up":	
        if v>=200: return "0,255,0"
        elif v>=150: return "0,225,0"
        elif v>=100: return "0,215,0"
        elif v>=95: return "0,200,0"
        elif v>=90: return "0,190,0"
        elif v>=85: return "0,180,0"
        elif v>=80: return "0,170,0"
        elif v>=75: return "0,160,0"
        elif v>=70: return "0,150,0"
        elif v>=65: return "0,140,0"
        elif v>=60: return "0,130,0"
        elif v>=55: return "0,120,0"
        elif v>=50: return "0,100,0"
        elif v>=45: return "50,100,255"
        elif v>=40: return "75,140,255"
        elif v>=35: return "100,160,255"
        elif v>=30: return "125,180,255"
        elif v>=25: return "150,200,255"
        elif v>=20: return "175,220,255"
        elif v>=15: return "200,240,255"
        elif v>=10: return "225,250,255"
        else: return "255,255,255"
    elif d=="dn":
        if v>=200: return "255,0,0"
        elif v>=150: return "225,0,0"
        elif v>=100: return "215,0,0"
        elif v>=95: return "200,0,0"
        elif v>=90: return "190,0,0"
        elif v>=85: return "180,0,0"
        elif v>=80: return "170,0,0"
        elif v>=75: return "160,0,0"
        elif v>=70: return "150,0,0"
        elif v>=65: return "140,0,0"
        elif v>=60: return "130,0,0"
        elif v>=55: return "120,0,0"
        elif v>=50: return "100,0,0"
        elif v>=45: return "255,100,100"
        elif v>=40: return "255,120,120"
        elif v>=35: return "255,140,140"
        elif v>=30: return "255,160,160"
        elif v>=25: return "255,180,180"
        elif v>=20: return "255,200,200"
        elif v>=15: return "255,225,225"
        elif v>=10: return "255,240,255"
        else: return "255,255,255"
    else: return "255,255,255"


global n, vsa
vsa = pd.DataFrame(index=np.arange(nRecords))
global UpBar,DnBar,NewHi,NewLo,NewHi10,NewLo10,RecentHigh,RecentLow
UpBar = [0 for i in range(nRecords)] #pd.DataFrame(index=np.arange(nRecords))
DnBar = [0 for i in range(nRecords)] #pd.DataFrame(index=np.arange(nRecords))
NewHi = [0 for i in range(nRecords)] #pd.DataFrame(index=np.arange(nRecords))
NewLo = [0 for i in range(nRecords)] #pd.DataFrame(index=np.arange(nRecords))
NewHi10 = [0 for i in range(nRecords)] #pd.DataFrame(index=np.arange(nRecords))
NewLo10 = [0 for i in range(nRecords)] #pd.DataFrame(index=np.arange(nRecords))
RecentHigh = [0 for i in range(nRecords)] #pd.DataFrame(index=np.arange(nRecords))
RecentLow = [0 for i in range(nRecords)] #pd.DataFrame(index=np.arange(nRecords))
 

global UltraHighBar, VeryHighBar, HighBar, LowBar, VeryLowBar
UltraHighBar = pd.DataFrame(index=np.arange(nRecords))
VeryHighBar = pd.DataFrame(index=np.arange(nRecords))
HighBar = pd.DataFrame(index=np.arange(nRecords))
LowBar = pd.DataFrame(index=np.arange(nRecords))
VeryLowBar = pd.DataFrame(index=np.arange(nRecords)) 

global vPerTick, vVolume, pSpread, pGain

for n in range(1,nRecords): 
    
    #print(Records['pZZMA5slope'][n])

    xEffortPrice=CheckInfNAN(iEffortPrice[n],0)
    if xEffortPrice>iSpread[nRecords-10]*2: xEffortPrice=iSpread[nRecords-10]*2
    if(iZZMA5[n]>=iZZMA5[n-1]): 
        iVolSpreadLow[n]=iHigh[n]
        iVolSpreadHigh[n]=iLow[n]+xEffortPrice
        iVolSpreadLowPerTick[n]=iHigh[n]
        iVolSpreadHighPerTick[n]=iLow[n]+CheckInfNAN(iEffortPricePerTick[n],0)
    else:
        iVolSpreadHigh[n]=iLow[n]
        iVolSpreadLow[n]=iHigh[n]-xEffortPrice
        iVolSpreadHighPerTick[n]=iLow[n]
        #hprint(f"[{n}] | [{iHigh[n]}] | [{iEffortPricePerTick[n]}]")
        iVolSpreadLowPerTick[n]=iHigh[n]-CheckInfNAN(iEffortPricePerTick[n],0)
    VolSpreadLowTO=0 
    VolSpreadHighTO=0
    if n>nRecords-500:
        if(iVolSpreadLow[n]<iLow[n] or iVolSpreadHigh[n]>iHigh[n]):
            if(abs(CheckInfNAN(iEffortPrice[n],0))>iSpreadMA[nRecords-10]):
                zbreak=0
                LL="-"
                HH="-"
                for z in range(n+1,nRecords): #(int z=n+1; z<sc.ArraySize; z++){ 	
                    
                    if VolSpreadLowTO==0:
                        if( (iVolSpreadLow[n]>=iLow[z] and iVolSpreadLow[n]<=iHigh[z]) or iLow[z]<=iVolSpreadLow[n]):
                            LL="X"
                            VolSpreadLowTO=z
                            zbreak=zbreak+1
                    if VolSpreadHighTO==0:   
                        if( (iVolSpreadHigh[n]>=iLow[z] and iVolSpreadHigh[n]<=iHigh[z]) or iHigh[z]>=iVolSpreadHigh[n]):
                            HH="X"
                            VolSpreadHighTO=z
                            zbreak=zbreak+1
                    #if(z==nRecords and VolSpreadLowTO==n): VolSpreadLowTO=nRecords
                    #if(z==nRecords and VolSpreadHighTO==n): VolSpreadHighTO=nRecords
                    
                    
                    #if n>nRecords-50:
                    #    hprint(f"{n}>{z} [{LL}] [{VolSpreadLowTO}] {iVolSpreadLow[n]} [{iLow[z]}..{iHigh[z]}] {iVolSpreadHigh[n]} [{VolSpreadHighTO}] [{HH}]")
                    if z==nRecords-1:  
                        #hprint("====================================")
                        #hprint(f"{n} | {VolSpreadLowTO} | {VolSpreadHighTO}")
                        if VolSpreadLowTO==0: VolSpreadLowTO=nRecords+2
                        if VolSpreadHighTO==0: VolSpreadHighTO=nRecords+2
                        #hprint(f"{n} | {VolSpreadLowTO} | {VolSpreadHighTO}")
                    
                    if zbreak==2:
                        #hprint("+++++++++++++++++++++++++++++++++++++")
                        if VolSpreadLowTO-n>1 or VolSpreadHighTO-n>1:
                            if not VolSpreadLowTO-n>1: VolSpreadLowTO=n
                            if not VolSpreadHighTO-n>1: VolSpreadHighTO=n
                            #hprint(f"{n}>{z} [{VolSpreadLowTO-n}] [{VolSpreadLowTO}] {iVolSpreadLow[n]} [{iLow[z]}..{iHigh[z]}] {iVolSpreadHigh[n]} [{TOH}] [{TOH-n}]")
                        break
                    
                         
    if VolSpreadLowTO==0: VolSpreadLowTO=n
    if VolSpreadHighTO==0: VolSpreadHighTO=n
    Records['VolSpreadLowTO'][n]=VolSpreadLowTO
    Records['VolSpreadHighTO'][n]=VolSpreadHighTO 
            
            #if(out==ArraySize): DrawDOMRectangles(sc,DrawingTool,nXline++,n,pLow[n],TO,VolSpreadLow,RGB(0,green,0),50,0,RGB(0,green,0),0);
            #else: 					DrawDOMRectangles(sc,DrawingTool,nXline++,n,pLow[n],TO,VolSpreadLow,RGB(red,0,0),50,0,RGB(red,0,0),0);
            #DrawDOMLine(sc,DrawingTool,nXline++,n,VolSpreadLow,n,VolSpreadHigh,Transparency(0,200,0,60),LINESTYLE_SOLID,bz,Above,0);//10 sc.ChartBarSpacing
            #DrawDOMMarker(sc,DrawingTool,nXline++,n,VolSpreadLow,Transparency(0,200,0,30),MARKER_POINT,3,3,false,0);
            #//DrawDOMRectangles(sc,DrawingTool,nXline++,n,VolSpreadLow,n+1,VolSpreadHigh,RGB(150,150,150),80,0,RGB(150,150,150),0);
        
            #if(VolSpreadHigh-pHigh[n]>sc.TickSize){
            

            #if(out==sc.ArraySize-1) DrawDOMRectangles(sc,DrawingTool,nXline++,n,pHigh[n],TO,VolSpreadHigh,RGB(red,0,0),50,0,RGB(red,0,0),0);
            #else					DrawDOMRectangles(sc,DrawingTool,nXline++,n,pHigh[n],TO,VolSpreadHigh,RGB(0,green,0),50,0,RGB(0,green,0),0);
            #DrawDOMLine(sc,DrawingTool,nXline++,n,VolSpreadLow,n,VolSpreadHigh,Transparency(200,0,0,60),LINESTYLE_SOLID,bz,Above,0);//10 sc.ChartBarSpacing
            #DrawDOMMarker(sc,DrawingTool,nXline++,n,VolSpreadHigh,Transparency(200,0,0,30),MARKER_POINT,3,3,false,0);
            #//DrawDOMRectangles(sc,DrawingTool,nXline++,n,VolSpreadLow,n+1,VolSpreadHigh,RGB(150,150,150),80,0,RGB(150,150,150),0);
    
    
    if n<len(Records)-1:
        if direction=="up" and iZZMA15[n+1]>=iZZMA15[n]:
            VolumeWave=VolumeWave+iVolume[n]
        elif direction=="dn" and iZZMA15[n+1]>iZZMA15[n]:
            VolumeWave=iVolume[n]
            direction="up"
        elif direction=="dn" and iZZMA15[n+1]<=iZZMA15[n]:
            VolumeWave=VolumeWave-iVolume[n]
        elif direction=="up" and iZZMA15[n+1]<iZZMA15[n]:
            VolumeWave=-iVolume[n]
            direction="dn" 
            
    vPerTick=abs((iVolumePerTick[n]*100)/(2*iVolumePerTickMA[n-1]))
    vVolume=abs((iVolume[n]*100)/(2*iVolMA[n-1]))
    clr=VolumeColor(vVolume,direction)
    Records['volColor'][n]=clr.replace(",","|")
    
    
    include(f"{dir}/py/incl-wyckoff.py")
    
    
    #hprint(row.pZZMA15) 
    
    dataOut+=f"""[{n},{iYear[n]},{iMonth[n]},{iDay[n]},{iHour[n]},{iMinute[n]},{idx[n]},{iOpen[n]},{iHigh[n]},{iLow[n]},{iClose[n]},{iVolume[n]},
    {CheckInfNAN(iZZMA5[n],iZZMA5[n-1])},{CheckInfNAN(iVolMA[n],iVolMA[n-1])},{CheckInfNAN(iVolumePerTick[n],iVolumePerTick[n-1])},{CheckInfNAN(iVolumePerTickMA[n],iVolumePerTickMA[n-1])},
    {CheckInfNAN(iSpread[n],iSpread[n-1])},{CheckInfNAN(iSpreadMA[n],iSpreadMA[n-1])},{CheckInfNAN(iZZMA15[n],iZZMA15[n-1])},{VolumeWave},
    {CheckInfNAN(Records['VolSpreadLowTO'][n],Records['VolSpreadLowTO'][n-1])},{CheckInfNAN(Records['VolSpreadHighTO'][n],Records['VolSpreadHighTO'][n-1])},
    {CheckInfNAN(iVolSpreadLow[n],iLow[n])},{CheckInfNAN(iVolSpreadHigh[n],iHigh[n])},'{Records['volColor'][n]}',0],"""
dataOut=dataOut.rstrip(",")+"]"
dataOut=dataOut.replace("inf","0") 


#Records.to_csv(f"{dir}/data/{quote}_{interval2}.txt", index = False)