import io, os, sys, types
from IPython import get_ipython
from nbformat import read
from IPython.core.interactiveshell import InteractiveShell
from pygments import highlight
from pygments.lexers import PythonLexer
from pygments.formatters import HtmlFormatter
from IPython.display import display, HTML

from binance.client import Client
import glob
import pandas as pd
import pytz
import datetime
import urllib3
import datetime
import math
import inspect
import jovian

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

def find_notebook(fullname, path=None):
    """find a notebook, given its fully qualified name and an optional path

    This turns "foo.bar" into "foo/bar.ipynb"
    and tries turning "Foo_Bar" into "Foo Bar" if Foo_Bar
    does not exist.
    """
    name = fullname.rsplit('.', 1)[-1]
    if not path:
        path = ['']
    for d in path:
        nb_path = os.path.join(d, name + ".ipynb")
        if os.path.isfile(nb_path):
            return nb_path
        # let import Notebook_Name find "Notebook Name.ipynb"
        nb_path = nb_path.replace("_", " ")
        if os.path.isfile(nb_path):
            return nb_path
        
        
class NotebookLoader(object):
    """Module Loader for Jupyter Notebooks"""
    def __init__(self, path=None):
        self.shell = InteractiveShell.instance()
        self.path = path

    def load_module(self, fullname):
        """import a notebook as a module"""
        path = find_notebook(fullname, self.path)

        print ("importing Jupyter notebook from %s" % path)

        # load the notebook object
        with io.open(path, 'r', encoding='utf-8') as f:
            nb = read(f, 4)


        # create the module and add it to sys.modules
        # if name in sys.modules:
        #    return sys.modules[name]
        mod = types.ModuleType(fullname)
        mod.__file__ = path
        mod.__loader__ = self
        mod.__dict__['get_ipython'] = get_ipython
        sys.modules[fullname] = mod

        # extra work to ensure that magics that would affect the user_ns
        # actually affect the notebook module's ns
        save_user_ns = self.shell.user_ns
        self.shell.user_ns = mod.__dict__

        try:
            for cell in nb.cells:
                if cell.cell_type == 'code':
                    # transform the input to executable Python
                    code = self.shell.input_transformer_manager.transform_cell(cell.source)
                    # run the code in themodule
                    exec(code, mod.__dict__)
        finally:
            self.shell.user_ns = save_user_ns
        return mod
    

class NotebookFinder(object):
    """Module finder that locates Jupyter Notebooks"""
    def __init__(self):
        self.loaders = {}

    def find_module(self, fullname, path=None):
        nb_path = find_notebook(fullname, path)
        if not nb_path:
            return

        key = path
        if path:
            # lists aren't hashable
            key = os.path.sep.join(path)

        if key not in self.loaders:
            self.loaders[key] = NotebookLoader(path)
        return self.loaders[key]
    
sys.meta_path.append(NotebookFinder())


formatter = HtmlFormatter()
lexer = PythonLexer()

# publish the CSS for pygments highlighting
display(HTML("""
<style type='text/css'>
%s
</style>
""" % formatter.get_style_defs()
))

def show_notebook(FILE_IDENTIFIER_STAMP, fname):
    """display a short summary of the cells of a notebook"""
    with io.open(fname, 'r', encoding='utf-8') as f:
        nb = read(f, 4)
    html = []
    for cell in nb.cells:
        html.append("<h4>%s cell</h4>" % cell.cell_type)
        if cell.cell_type == 'code':
            html.append(highlight(cell.source, lexer, formatter))
        else:
            html.append("<pre>%s</pre>" % cell.source)
    html = HTML('\n'.join(html))
    filepath = FILE_IDENTIFIER_STAMP + '/' + fname.split('.')[0] + '.html'
    print(filepath)
    with open(filepath, 'w') as f:
        f.write(html.data)


from scrape_price_data import scrap_binance_price
# from import_static_price_data import scrap_binance_price
from atr_renko_ema_on_renko_calculation import calculate_renko_atr_with_ema
# from atr_renko_ema_on_renko_calculation_with_hold import calculate_renko_atr_with_ema
from simulation_using_csv import Simulation
from print_graph import print_simulation_graph
from Time_Analysis import time_analysis
from Matrix import create_matrix

now = datetime.datetime.now()

def run ():
    TIME_PERIOD_INFO = CANDLE_START_TIME.split(",")
    FILE_IDENTIFIER_STAMP = SYMBOL + "|" + CANDLE_TIME_INTERVAL + "|" + TIME_PERIOD_INFO[0] + \
    TIME_PERIOD_INFO[1] + "|" + EMA_TYPE  + "|" + "EMA_SPAN_" + str(EMA_SPAN) + "|" + "ATR_"  + str(ATR) + \
    "|" + "ATR_WINDOW_" + str(ATR_WINDOW) + "|"
    FILE_IDENTIFIER_STAMP += now.strftime("%m-%d-%YT%H%M")
    os.mkdir(FILE_IDENTIFIER_STAMP)
    os.mkdir(FILE_IDENTIFIER_STAMP + "/Source")
    
    show_notebook(FILE_IDENTIFIER_STAMP + "/Source", os.path.join("", "scrape_price_data.ipynb"))
    show_notebook(FILE_IDENTIFIER_STAMP + "/Source", os.path.join("", "simulation_using_csv.ipynb"))
    show_notebook(FILE_IDENTIFIER_STAMP + "/Source", os.path.join("", "print_graph.ipynb"))
    
    RAW_DATA_OUTPUT = FILE_IDENTIFIER_STAMP + "/Binance_Candles_" + FILE_IDENTIFIER_STAMP + ".csv"
    scrap_binance_price(SYMBOL, CANDLE_TIME_INTERVAL, CANDLE_START_TIME, RAW_DATA_OUTPUT)
    
    ATR_RENKO_DATA_OUTPUT = FILE_IDENTIFIER_STAMP + "/ATR_Renko_" + FILE_IDENTIFIER_STAMP + ".csv"
    
    calculate_renko_atr_with_ema(RAW_DATA_OUTPUT, ATR_RENKO_DATA_OUTPUT, ATR, EMA_TYPE, EMA_SPAN, ATR_WINDOW, renko_price, prev_renko)
    show_notebook(FILE_IDENTIFIER_STAMP + "/Source", os.path.join("", "atr_renko_ema_on_renko_calculation.ipynb"))
    # calculate_renko_atr(RAW_DATA_OUTPUT, ATR_RENKO_DATA_OUTPUT)
    
    SIMULATION_RESULTS_OUTPUT = FILE_IDENTIFIER_STAMP + "/TradingSimulation_" + FILE_IDENTIFIER_STAMP + ".csv"
    s = Simulation(ATR_RENKO_DATA_OUTPUT, SIMULATION_RESULTS_OUTPUT)
    trading_record = s.run_bot(STARTING_MONEY, STARTING_BTC)
    print_simulation_graph(SIMULATION_RESULTS_OUTPUT, FILE_IDENTIFIER_STAMP)
    MATRIX_OUTPUT = FILE_IDENTIFIER_STAMP + "/Matrix_" + FILE_IDENTIFIER_STAMP + ".csv"
    matrix = create_matrix(trading_record, FILE_IDENTIFIER_STAMP, MATRIX_OUTPUT)
    os.rename(FILE_IDENTIFIER_STAMP, str(math.floor(trading_record.iloc[-1]["total"])) + FILE_IDENTIFIER_STAMP)
    INPUT_FILES.append(matrix)

params = [
  {
    "SYMBOL": "BTCUSDT",
    "CANDLE_TIME_INTERVAL": "2h",
    "CANDLE_START_TIME": "20 Nov, 2017",
    "EMA": "renko_price",
    "ATR": "variable",
    "EMA_SPAN": 20,
    "ATR_WINDOW": 5,
    "RENKO_PRICE": 8053,
    "PREV_IND": 1
  },
  {
    "SYMBOL": "BTCUSDT",
    "CANDLE_TIME_INTERVAL": "2h",
    "CANDLE_START_TIME": "20 Nov, 2017",
    "EMA": "renko_price",
    "ATR": "variable",
    "EMA_SPAN": 22,
    "ATR_WINDOW": 5,
    "RENKO_PRICE": 8053,
    "PREV_IND": 1
  }
]

INPUT_FILES = []
for param in params:
    CANDLE_TIME_INTERVAL = param["CANDLE_TIME_INTERVAL"]
    CANDLE_START_TIME = param["CANDLE_START_TIME"]
    SYMBOL = param["SYMBOL"]
    EMA_TYPE = param["EMA"]
    EMA_SPAN = param["EMA_SPAN"]
    ATR_WINDOW = param["ATR_WINDOW"]
    ATR = param["ATR"]
    renko_price = param["RENKO_PRICE"]
    prev_renko = param["PREV_IND"]
    STARTING_MONEY, STARTING_BTC = 0, 1
    run()
time_analysis(INPUT_FILES, "Master_Matrix.csv")

jovian.commit(project="BitBotBoom_Simulation_Pipeline", environment=None, filename="/home/ec2-user/SageMaker/Renko Simulation/Pipeline.ipynb", message="Revert to Owen's version.")