from zipline.api import order_value, record, symbol
from zipline import run_algorithm
import pandas as pd
import numpy as np

class BackTest(object):

    start = pd.Timestamp('2016-01-01', tz='utc')
    end = pd.Timestamp('2018-01-01', tz='utc')

    def __init__(self):
        self.stock = None

    def average(self, string, days):
        days = abs(days)
        if days != days:
            return 0
        if days > 300:
            days = 300
        if days < 1:
            days = 1
        try:
            average = self.data.history(
                self.context.asset, string, bar_count=int(days), frequency="1d").mean()
        except IndexError:
            average = 0
            print('error avg')
        if np.isnan(average):
            average = 0
        return average

    def maximum(self, string, days):
        days = abs(days)
        if days != days:
            return 0
        if days > 300:
            days = 300
        if days < 1:
            days = 1
        try:
            maximum = self.data.history(
                self.context.asset, string, bar_count=int(days), frequency="1d").max()
        except IndexError:
            maximum = 0
            print('error max')
        if np.isnan(maximum):
            maximum = 0
        return maximum

    def minimum(self, string, days):
        days = abs(days)
        if days != days:
            return 0
        if days > 300:
            days = 300
        if days < 1:
            days = 1
        try:
            minimum = self.data.history(
                self.context.asset, string, bar_count=int(days), frequency="1d").min()
        except IndexError:
            minimum = 0
            print('error min')
        if np.isnan(minimum):
            minimum = 0
        return minimum

    def lag(self, string, days):
        days = abs(days)
        if days != days:
            return 0
        if days > 300:
            days = 300
        if days < 1:
            days = 1
        try:
            lag = self.data.history(
                self.context.asset, string, bar_count=int(days), frequency="1d")[0]
        except IndexError:
            lag = 0
            print(context.asset)
            print('error lag')
        if np.isnan(lag):
            lag = 0
        return lag

    def current_price(self):
        price = self.data.current(self.context.asset, 'price')
        if np.isnan(price):
            price = 0
        return price

    def current_vol(self):
        volume = self.data.current(self.context.asset, 'volume')
        if np.isnan(volume):
            volume = 0
        self.volume = volume
        return volume

    def initialize(self, context):
        context.i = 0
        context.asset = symbol('AAPL')

    def handle_data(self, context, data):
        # Skip first 300 days to get full windows
        context.i += 1
        if context.i < 300:
            return
        # Trading logic
        self.data = data
        self.context = context
        if(75 > self.current_vol()):
          order_value(context.asset, 10000)
        if(274 > 206):
          order_value(context.asset, -10000)

    def analyze(self, context, perf):
        self.sortino = perf.sortino[-1]
        self.sortinos = perf.sortino
        self.port = perf.portfolio_value
        # print(perf.portfolio_value[-1], self.sortino, perf.sortino[-1])
        if (self.sortino == None):
            self.sortino = 0

    def run(self):
        run_algorithm(start=self.start, end=self.end, initialize=self.initialize,
                      capital_base=100000.0, handle_data=self.handle_data,
                      bundle='quantopian-quandl', analyze=self.analyze)

backtest = BackTest()
backtest.run()
print(backtest.sortino)