"""
@author: luojunhui
"""
from applications.functions import chunks, get_info_lists, title_filter
from applications.config import minigram_info


class VideoDeal(object):
    """
    Deal Request from outside
    """

    def __init__(self, params, mysql_client):
        self.start_dt = params['start_date']
        self.end_dt = params['end_date']
        self.cate = params['cate']
        self.topN = params['topN'] if params.get("topN") else 1
        self.mysql_client = mysql_client

    def response_obj(self, data_list):
        """
        处理 return 信息
        :param data_list:
        :return:video_id, title, view_, return_, video_url, rov
        """
        L = []
        sub_list = chunks(data_list, 20)
        for temp_list in sub_list:
            vid_list = [i[0] for i in temp_list]
            pq_response = get_info_lists(vid_list=vid_list)
            cover_list = [i['shareImgPath'] for i in pq_response['data']]
            publish_time_list = [i['gmtCreateTimestamp'] for i in pq_response['data']]
            for index, obj in enumerate(temp_list):
                temp = {
                    "video_id": obj[0],
                    "title": obj[1],
                    "view": obj[2],
                    "return": obj[3],
                    "video_url": obj[4],
                    "rov": obj[5],
                    "video_text": "",
                    "publish_time": publish_time_list[index],
                    "cover": cover_list[index],
                    "minigram_info": minigram_info
                }
                L.append(temp)
        response = {
            "status": "success",
            "cate": self.cate,
            "start_date": self.start_dt,
            "end_dt": self.end_dt,
            "topN": self.topN,
            "data": L
        }
        return response

    async def deal(self):
        """
        deal function
        :return:
        """
        if self.cate == "video_return":
            return await self.deal_return()
        elif self.cate == "video_view":
            return await self.deal_view()
        elif self.cate == "video_rov":
            return await self.deal_rov()
        else:
            return {"error": "params is not correct"}

    async def deal_return(self):
        """
        return
        :return:
        """
        sql = f"""
        select video_id, title, view_, return_, video_url, rov
        from top_return_daily 
        where dt >= '{self.start_dt}' and dt < '{self.end_dt}' 
        order by return_ DESC
        limit {self.topN};
        """
        result_list = await self.mysql_client.select(sql)
        title_list = [i[1] for i in result_list]
        score_list = title_filter(title_list)
        # print(score_list)
        res = list(zip(score_list, title_list))
        s_r = sorted(res, key=lambda x:x[0], reverse=True)
        for i in s_r:
            print(i)
        result_list_final = []
        for index, item in enumerate(result_list):
            if score_list[index] > 0.5:
                result_list_final.append(item)
        return self.response_obj(result_list_final)

    async def deal_view(self):
        """
        view
        :return:
        """
        sql = f"""
        select video_id, title, view_, return_, video_url, rov
        from top_return_daily 
        where dt >= '{self.start_dt}' and dt < '{self.end_dt}' 
        order by view_  DESC
        limit {self.topN}
        """
        result_list = await self.mysql_client.select(sql)
        return self.response_obj(result_list)

    async def deal_rov(self):
        """
        rov
        :return:
        """
        sql = f"""
        select video_id, title, view_, return_, video_url, rov
        from top_return_daily 
        where dt >= '{self.start_dt}' and dt < '{self.end_dt}' 
        order by rov DESC
        limit {self.topN}
        """
        result_list = await self.mysql_client.select(sql)
        return self.response_obj(result_list)