import numpy as np
import datetime
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import math

# 平滑价格
# @inP [,,,,] 价格数组
class SmoothPrice:

    def __init__(self,inP:np.ndarray):
        self.__inP__ = inP
        self.__l_smooth__ = inP
        self.__q_smooth__ = inP
        self.__c_smooth__ = inP

    def __linearSmooth5__(self):
        _outP = []
        inP = self.__inP__
        n = len (inP)
        if n < 5:
            for i in inP:
                _outP.append (i)
        else:
            _outP.append ((3.0 * inP[0] + 2.0 * inP[1] + inP[2] - inP[4]) / 5.0)
            _outP.append ((4.0 * inP[0] + 3.0 * inP[1] + 2 * inP[2] + inP[3]) / 10.0)
            _i = 0
            for i in inP:
                if not _i == 0 and not _i == 1 and not _i == n - 2 and not _i == n - 1:
                    _outP.append ((inP[_i - 2] + inP[_i - 1] + inP[_i] + inP[_i + 1] + inP[_i + 2]) / 5.0)
                _i = _i + 1
            _outP.append ((4.0 * inP[n - 1] + 3.0 * inP[n - 2] + 2 * inP[n - 3] + inP[n - 4]) / 10.0)
            _outP.append ((3.0 * inP[n - 1] + 2.0 * inP[n - 2] + inP[n - 3] - inP[n - 5]) / 5.0)
        self.__l_smooth__ = _outP

    def __quadraticSmooth5__(self):
        _outP = []
        inP = self.__l_smooth__
        n = len (inP)
        if n < 5:
            for i in inP:
                _outP.append (i)
        else:
            _outP.append ((31.0 * inP[0] + 9.0 * inP[1] - 3.0 * inP[2] - 5.0 * inP[3] + 3.0 * inP[4]) / 35.0)
            _outP.append ((9.0 * inP[0] + 13.0 * inP[1] + 12 * inP[2] + 6.0 * inP[3] - 5.0 * inP[4]) / 35.0)
            _i = 0
            for i in inP:
                if not _i == 0 and not _i == 1 and not _i == n - 2 and not _i == n - 1:
                    _outP.append ((- 3.0 * (inP[_i - 2] + inP[_i + 2]) + 12.0 * (inP[_i - 1] + inP[_i + 1]) + 17 * inP[
                        _i]) / 35.0)
                _i = _i + 1
            _outP.append (
                (9.0 * inP[n - 1] + 13.0 * inP[n - 2] + 12.0 * inP[n - 3] + 6.0 * inP[n - 4] - 5.0 * inP[n - 5]) / 35.0)
            _outP.append (
                (31.0 * inP[n - 1] + 9.0 * inP[n - 2] - 3.0 * inP[n - 3] - 5.0 * inP[n - 4] + 3.0 * inP[n - 5]) / 35.0)
        self.__q_smooth__ = _outP

    def __cubicSmooth5__(self):
        _outP = []
        inP = self.__q_smooth__
        n = len (inP)
        if n < 5:
            for i in inP:
                _outP.append (i)
        else:
            _outP.append ((69.0 * inP[0] + 4.0 * inP[1] - 6.0 * inP[2] + 4.0 * inP[3] - inP[4]) / 70.0)
            _outP.append ((2.0 * inP[0] + 27.0 * inP[1] + 12.0 * inP[2] - 8.0 * inP[3] + 2.0 * inP[4]) / 35.0)
            _i = 0
            for i in inP:
                if not _i == 0 and not _i == 1 and not _i == n - 2 and not _i == n - 1:
                    _outP.append ((-3.0 * (inP[_i - 2] + inP[_i + 2]) + 12.0 * (inP[_i - 1] + inP[_i + 1]) + 17.0 * inP[
                        _i]) / 35.0)
                _i = _i + 1
            _outP.append (
                (2.0 * inP[n - 5] - 8.0 * inP[n - 4] + 12.0 * inP[n - 3] + 27.0 * inP[n - 2] + 2.0 * inP[n - 1]) / 35.0)
            _outP.append (
                (- inP[n - 5] + 4.0 * inP[n - 4] - 6.0 * inP[n - 3] + 4.0 * inP[n - 2] + 69.0 * inP[n - 1]) / 70.0)
        self.__c_smooth__ = _outP

    def smooth(self):
        self.__linearSmooth5__()
        self.__quadraticSmooth5__()
        self.__cubicSmooth5__()
        return self.__c_smooth__

class SeasonReports:
    def __init__(self):
        self.__today__ = datetime.date.today()
        self.__toyear__ = datetime.datetime(self.__today__.year,1,1)
        self.__lastyear__ = datetime.datetime((self.__toyear__ - datetime.timedelta(days=1)).year,1,1)
        self.__lasttwoyear__ = datetime.datetime((self.__lastyear__ - datetime.timedelta(days=1)).year,1,1)

    def seasonDaily(self):
        season = ['q4','q3','q2','q1']
        # print([str(self.__toyear__.year)+i for i in season]+[str(self.__lastyear__.year)+i for i in season]+[str(self.__lasttwoyear__.year)+i for i in season])
        _out = [str(self.__toyear__.year)+i for i in season]+[str(self.__lastyear__.year)+i for i in season]+[str(self.__lasttwoyear__.year)+i for i in season]
        _out.reverse()
        return _out
    
#处理股票代码
class Stocks:

    def combineIdustryStocks(self,industries:list):
        return  np.hstack([ get_industry_stocks(i)  for i in industries])

    def standardStocks(self,stockList):
        _stocks = list(get_all_securities('stock').index)
        _standardStocks = []
        for i in stockList:
            _standardStocks =_standardStocks+[code for code in _stocks if code.upper().startswith(i)]
        return _standardStocks
    
class TargetStock:

    def __init__(self,standardRate = 0.06):
        self.__standardRate__ = standardRate

    def setSeasonReport(self,seasonDaily,stock):
        list =[]
        # print(seasonDaily)
        for _season in seasonDaily:
            jqv = valuation
            df = get_fundamentals(query(jqv.code,jqv.circulating_cap,jqv.capitalization,income.net_profit,jqv.market_cap,balance.fixed_assets,indicator.eps
                                              ).filter(jqv.code == stock
                                                       ).order_by(
                                                                  ),statDate = _season
                                    )
            if not df.empty:
                list.append([
                    ('net_profit',df['net_profit'][0]),
                    ('circulating_cap',df['circulating_cap'][0]),
                    ('capitalization',df['capitalization'][0]),
                    ('seasonReport',_season),
                    ('fixed_assets'+_season,df['fixed_assets'][0]),
                    ('eps',df['eps'][0])
                    ])
        return list

    def getstockPrice(self,stock,days = 200,end_date = datetime.date.today(),frequency = 'daily'):
        _points = get_price(stock,count=days,end_date= end_date,frequency=frequency,fields=['close','volume'],fq=None)
        _in = _points['close'].values[:days]
        _in_volume = _points['volume'].values[:days]
        sp_in = SmoothPrice(_in)
        sp_in_volume = SmoothPrice(_in_volume)
        y_in = sp_in.smooth()
        volume_in = sp_in_volume.smooth()
        y_base = _in
        x=range(days)
        sr = SeasonReports()
        stock_sel = self.setSeasonReport(sr.seasonDaily(),stock)
        if len(stock_sel) < 6:
            print('warning,-'+stock+'-seasons is not enough!')
            return False
        stock_sel.reverse()
        last_net_profit =sum([i[0][1] for i in stock_sel[1:4]])
        # print([i[0][1] for i in stock_sel[:4]])
        pre_net_profit = sum([i[0][1] for i in stock_sel[2:5]])
        base_net_profit = sum([i[0][1] for i in stock_sel[3:6]])
        # print(stock,[last_net_profit,pre_net_profit,base_net_profit])
        def fixed_assert(i):
            return stock_sel[i][4][1]
        def circulating_cap(i):
            return 10000*stock_sel[i][1][1]
        def capitalization(i):
            return 10000*stock_sel[i][2][1]
        last_target_price_circap = ((last_net_profit - fixed_assert(0)+fixed_assert(3))/self.__standardRate__)/circulating_cap(0)
        last_target_price_cap = ((last_net_profit - fixed_assert(0)+fixed_assert(3))/self.__standardRate__)/capitalization(0)
        pre_target_price_circap = ((pre_net_profit - fixed_assert(1)+fixed_assert(4))/self.__standardRate__)/circulating_cap(1)
        pre_target_price_cap = ((pre_net_profit - fixed_assert(1)+fixed_assert(4))/self.__standardRate__)/capitalization(1)
        base_target_price_circap = ((base_net_profit - fixed_assert(2)+fixed_assert(5))/self.__standardRate__)/circulating_cap(2)
        base_target_price_cap = ((base_net_profit - fixed_assert(2)+fixed_assert(5))/self.__standardRate__)/capitalization(2)
        # print([not math.isnan(i) for i in [last_target_price_circap,last_target_price_cap,pre_target_price_circap,pre_target_price_cap,base_target_price_circap,base_target_price_cap]])
        for i in [math.isnan(i) for i in [last_target_price_circap,last_target_price_cap,pre_target_price_circap,pre_target_price_cap,base_target_price_circap,base_target_price_cap]]:
            if i :
                print('warning,-'+stock+'-can\'t find enough circap or cap')
                return False
        # print(stock,[(last_target_price_circap,last_target_price_cap),
        #                 (pre_target_price_circap,pre_target_price_cap),
        #                 (base_target_price_circap,base_target_price_cap)
        #                ])
        # print([i[3][1] for i in stock_sel])
        return [('smoothPrice',y_in),('truthPrice',y_base),('x_axis',x),(
            'report',[('last_target_price_circap',int(last_target_price_circap)),
                      ('last_target_price_cap',int(last_target_price_cap)),
                      ('pre_target_price_circap',int(pre_target_price_circap)),
                      ('pre_target_price_cap',int(pre_target_price_cap)),
                      ('base_target_price_circap',int(base_target_price_circap)),
                      ('base_target_price_cap',int(base_target_price_cap))
                      ]),
                ('in_volume',volume_in),
                ('stock',stock),
                ('reportSeason',[i[3][1] for i in stock_sel])]

    def plotFigure(self,getstockPrice):
        if   getstockPrice == False or len(getstockPrice) != 7:
            print('warning empty')
            return False
        stock = getstockPrice[5][1]
        reportSeason = getstockPrice[6][-1][0]
        smoothPrice = getstockPrice[0]
        truthPrice = getstockPrice[1]
        x_axis = getstockPrice[2]
        report = getstockPrice[3]
        in_volume = getstockPrice[4]

        plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
        plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
        fig = plt.figure (tight_layout=False,figsize=(13, 30))
        gs = gridspec.GridSpec (2, 2)


        ax = fig.add_subplot (gs[0, :])
        ax.plot (x_axis[1], smoothPrice[1], "b")
        ax.plot (x_axis[1], truthPrice[1], "y")
        # ax.set_ylabel ('YLabel0')
        ax.set_xlabel ('最近预估g(-[总股份]/--[流通股份]),上一季度起点y,上上季度起点r')
        ax.axhline ((report[1][0][1]), color='g', linestyle='--', label='last_target_price_circap')
        ax.axhline ((report[1][1][1]), color='g', linestyle='-', label='last_target_price_cap')
        ax.axhline (report[1][2][1], color='y', linestyle='--', label='pre_target_price_circap')
        ax.axhline (report[1][3][1], color='y', linestyle='-', label='pre_target_price_cap')
        ax.axhline (report[1][4][1], color='r', linestyle='--', label='base_target_price_circap')
        ax.axhline (report[1][5][1], color='r', linestyle='-', label='base_target_price_cap')
        ax.grid ()

        ax = fig.add_subplot (gs[1, :])
        ax.set_ylabel ('量  能')
        ax.plot (x_axis[1], in_volume[1], 'g')
        ax.grid () 
      
        plt.show()

_st = Stocks()
_sd = SeasonReports()
_as = TargetStock()
_as.plotFigure(_as.getstockPrice(stock=_st.standardStocks(stockList=['000915'])[0]))