import os
import time
import logging
import requests
import datetime

from lxml import etree
from injector.models import TaskModel
from injector.models import MediaInfoSyncModel
from domain.lsp.generated.anhuizx_xsd import Adi
from domain.lsp.base_injector import LspInjectorC2
from domain.lsp.value_object import C2ApiUtil, CodeFactory
from domain.injector.value_object import TaskStatusValue
from domain.injector.value_object import DefinitionValue

from utils.date_utils import datetime_now
import xml.etree.ElementTree as ET
from utils.defines import ResponseCode
from domain.lsp.anhuizhongxing4k_domain import AnHuiZhongXing4K

logger = logging.getLogger(__file__)


class AnHuiZhongXing(LspInjectorC2):

    def __init__(self, alias="ANHUIZHONGXING"):
        super().__init__(alias)
        self.lsp_id = self.conf.lsp_id
        self.csp_id = self.conf.csp_id
        self.cms_api = self.conf.cms_api
        self.csp_name = self.conf.csp_name
        self.code_factory = CodeFactory(self.csp_id)
        self.cast_sep = "|"
        self.genre_sep = "|"
        self.is_divide_series = True
        self.all_series_first = True
        self.is_old_movie = False

    def _get_bit_rate_type(self, definition):
        BIT_RATE_TYPE_MAP = {
            DefinitionValue.P320: 3,  # 2/3 D1
            DefinitionValue.P480: 5,  # D1
            DefinitionValue.P720: 6,  # 720P
            DefinitionValue.P1080: 8,  # 1080P
            DefinitionValue.K4: 8,  # 4K 对方没有展示设置为1080P
        }
        return BIT_RATE_TYPE_MAP.get(definition, 3)

    def bit_rate_transform(self, bit_rate):
        BIT_RATE_MAP = {1634.8: 1, 2150.4: 2, 8192: 3, 60: 4, 150: 5, 420: 6, 750: 7}
        BRM = [60, 150, 420, 750, 1634.8, 2150.4, 8192]
        _new_bit_poor = [abs(bit_rate - i) for i in BRM]
        min_poor = min(_new_bit_poor)
        min_bit = BRM[_new_bit_poor.index(min_poor)]
        return BIT_RATE_MAP.get(min_bit)

    def generate_code(self, _code, category):
        """
        安徽移动新发布code规范,规范{0}{1}{2}，不足补在{2}之前补0, 32位
        0：CMSID后5位
        1: 对象类型对应,见Object_map
        2: 自己平台编码
        """
        _OBJECT_MAP = {
            "Program": "001",
            "Movie": "002",
            "Cast": "003",
            "CastRoleMap": "004",
            "Channel": "005",
            "PhysicalChannel": "006",
            "Schedule": "007",
            "Picture": "008",
            "Category": "009",
            "Series": "010",
            "Package": "011"
        }
        after_list = _code.split("-")[:2]
        after = "".join(after_list).rjust(24, "0")
        in_the = _OBJECT_MAP[category]
        before = str(self.lsp_id)[-5:]
        return "{}{}{}".format(before, in_the, after)

    def v_codec_transform(self, v_codec):
        V_CODEC_MAP = {
            "h264": 1,  # H.264
            "mpeg4": 2,  # MPEG4
            "mpeg2video": 3  # MPEG2
        }
        return V_CODEC_MAP.get(v_codec, 2)

    def property_series(self, _id, volumn_count, media, action="REGIST"):
        search_name = self.transform_chinese_to_letter(self.get_media_name_by_alias(media))
        param_dict = {"category": media.category, "is_charge": 1}
        change_fields = self.injected_change.get_injected_fields(media.id, self.lsp_pk, param_dict)
        actors, directors, writers = self.get_media_person(media, actor=4, director=4, writer=2)
        the_property = [
            {"Name": self.get_media_name_by_alias(media)},
            {"SearchName": search_name},
            {"ActorDisplay": actors},
            {"WriterDisplay": writers},
            {"Director": directors},
            {"OrgAirDate": "".join(media.date_published.split("-"))},
            {"VolumnCount": volumn_count},
            {"Status": 1},
            {"Description": media.storyline},
            {"OriginalCountry": self.get_regions(media)},
            {"area": self.get_regions(media)},
            {"Language": media.languages},
            {"Type": self._get_category_desc(change_fields["category"])},
            {"Genre": self.get_genre(media)},
            {"Reserve1": change_fields["is_charge"]},
            {"ReleaseYear": media.year},
            {"TitleSC": self.get_media_name_by_alias(media)},
            {"ScoreSC": media.douban_score}
        ]
        return {
            "element_type": "Series",
            "id": _id,
            "code": _id,
            "action": action,
            "property": the_property
        }

    def property_program(self, _id, name, media, action="REGIST"):
        search_name = self.transform_chinese_to_letter(name.replace(" ", ""))
        param_dict = {"category": media.category, "is_charge": 1}
        change_fields = self.injected_change.get_injected_fields(media.id, self.lsp_pk, param_dict)
        return {
            "element_type": "Program",
            "id": _id,
            "code": _id,
            "action": action,
            "property": [
                {"Name": name},
                {"SearchName": search_name},
                {"OriginalCountry": self.get_regions(media)},
                {"Language": media.languages},
                {"ReleaseYear": media.year},
                {"Description": media.storyline},
                {"Genre": self.get_genre(media)},
                {"Status": 1},
                {"Type": self._get_category_desc(change_fields["category"])},
                # 0 免费 1 收费
                {"Bcharging": change_fields["is_charge"]},
                {"TitleSC": self.get_media_name_by_alias(media)},
                {"ScoreSC": media.douban_score}
            ]
        }

    def property_movie(self, _id, media_storage, _type=1, action="REGIST"):
        return {
            "element_type": "Movie",
            "id": _id,
            "code": _id,
            "action": action,
            "property": [
                {"Type": _type},
                {"FileURL": media_storage.url},
                {"AudioType": self.get_audio_type(media_storage.a_codec)},
                {"ClosedCaptioning": 1},
                {"Duration": time.strftime("%H%M%S00", time.gmtime(media_storage.seconds))},
                {"BitRateType": self.bit_rate_transform(media_storage.bit_rate)},
                {"VideoType": self.v_codec_transform(media_storage.v_codec)},
                {"AudioFormat": 2},
                {"Resolution": self._get_bit_rate_type(media_storage.definition)},
                {"SystemLayer": 1}
            ]
        }

    def property_picture(self, _id, file_url, _type=1, action="REGIST"):
        return {
            "element_type": "Picture",
            "id": _id,
            "code": _id,
            "action": action,
            "property": [
                {"Type": _type},
                {"FileURL": self.to_ip_url(file_url)},
            ]
        }

    def _album_movie(self, media_storage, media, episode, media_ext, action="REGIST"):
        actors, directors, writers = self.get_media_person(media, actor=4, director=4, writer=2)
        vst, vet = self.get_episode_effective_time(media.id, episode.serial_num)
        media_verpic = self.image_resize.get_oss_resize_params(self.partner_alias, media_ext.media_verpic,
                                                               size=media_ext.verpic_size, to_ip=True)

        _ppid = self.code_factory.gen_program_code(media.id)
        ppid = self.generate_code(_ppid, "Program")
        p_program = self.property_program(ppid, self.get_media_name_by_alias(media), media, action=action)
        p_program["property"].extend([
            {"ActorDisplay": actors},
            {"WriterDisplay": writers},
            {"LicensingWindowStart": vst},
            {"LicensingWindowEnd": vet},
            {"SeriesFlag": 0},
            {"Duration": time.strftime("%H%M%S00", time.gmtime(media_storage.seconds))},
            {"Director": directors},
            {"ImageSC": self.to_ip_url(media_verpic)},
            {"UpdateTimeSC": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
        ])

        _pmid = self.code_factory.gen_movie_code(media_storage.id)
        pmid = self.generate_code(_pmid, "Movie")
        p_movie = self.property_movie(pmid, media_storage, action=action)
        mapping_movie = self.property_mapping("Program", "Movie", ppid, pmid, action=action)

        _pmpid = self.code_factory.gen_media_vpic_code(episode.id)
        pmpid = self.generate_code(_pmpid, "Picture")
        p_program_picture = self.property_picture(pmpid, media_verpic, action=action)
        mapping_program_picture = self.property_mapping("Picture", "Program", pmpid, ppid, sequence=1, action=action)

        mapping_package = self.property_mapping("Package", "Program", "BP8168", ppid, sequence=episode.serial_num,
                                                action=action)
        return {
            "domain": "2",
            "object_list": [p_program, p_movie, p_program_picture],
            "mapping_list": [mapping_movie, mapping_program_picture, mapping_package],
        }

    def _album_series_header(self, media, media_ext, info_sync):
        action = info_sync.action_description()
        # action = "REGIST"
        _episodes = int(media.episodes) if media.episodes else 0
        vst, vet = self.get_media_effective_time(media.id)
        media_verpic = self.image_resize.get_oss_resize_params(self.partner_alias, media_ext.media_verpic,
                                                               size=media_ext.verpic_size, to_ip=True)

        media_horpic = self.image_resize.get_oss_resize_params(self.partner_alias, media_ext.media_horpic,
                                                               size=media_ext.horpic_size, to_ip=True)

        _psid = self.code_factory.gen_series_code(media.id)
        psid = self.generate_code(_psid, "Series")
        if self.is_old_movie:
            psid = self.generate_code(_psid, "Program")
        p_series = self.property_series(psid, _episodes, media, action=action)
        p_series["property"].extend([
            {"Reserve2": self.to_ip_url(media_horpic)},
            {"LicensingWindowStart": vst},
            {"LicensingWindowEnd": vet},
            {"ImageSC": self.to_ip_url(media_verpic)},
            {"UpdateTimeSC": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
        ])

        _pspcid = self.code_factory.gen_media_vpic_code(media.id)
        pspcid = self.generate_code(_pspcid, "Picture")
        p_series_picture = self.property_picture(pspcid, media_verpic, action=action)
        mapping_series_picture = self.property_mapping("Picture", "Series", pspcid, psid, sequence=1, action=action)

        mapping_package_series = self.property_mapping("Package", "Series", self.csp_name, psid, action=action)

        return {
            "domain": "2",
            "object_list": [p_series, p_series_picture],
            "mapping_list": [mapping_series_picture, mapping_package_series]
        }

    def _album_sub_series(self, media_storage, media, media_ext, episode, _episodes, action="REGIST"):
        actors, directors, writers = self.get_media_person(media, actor=4, director=4, writer=2)
        vst, vet = self.get_episode_effective_time(media.id, episode.serial_num)
        episode_horpic = self.image_resize.get_oss_resize_params(self.partner_alias, episode.episode_horpic,
                                                                 size=episode.horpic_size, to_ip=True)
        _psid = self.code_factory.gen_series_code(media.id)
        psid = self.generate_code(_psid, "Series")
        episode_title = self.get_episode_title(media, episode)

        _ppid = self.code_factory.gen_program_code(media_storage.id)
        ppid = self.generate_code(_ppid, "Program")
        p_program = self.property_program(ppid, episode_title, media, action=action)
        p_program["property"].extend([
            {"ActorDisplay": actors},
            {"WriterDisplay": writers},
            {"LicensingWindowStart": vst},
            {"LicensingWindowEnd": vet},
            {"SeriesFlag": 1},
            {"Duration": time.strftime("%H%M%S00", time.gmtime(media_storage.seconds))},
            {"Director": directors},
            {"ImageSC": self.to_ip_url(episode_horpic)},
            {"UpdateTimeSC": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")},
            {"SeriesCodeSC": psid}
        ])

        _pmid = self.code_factory.gen_movie_code(media_storage.id)
        pmid = self.generate_code(_pmid, "Movie")
        p_movie = self.property_movie(pmid, media_storage, action=action)
        mapping_movie = self.property_mapping("Program", "Movie", ppid, pmid, action=action)

        _pmpid = self.code_factory.gen_episode_picture_code(episode.id)
        pmpid = self.generate_code(_pmid, "Picture")
        p_program_picture = self.property_picture(pmpid, episode_horpic, action=action)
        mapping_program_picture = self.property_mapping("Picture", "Program", pmpid, ppid, sequence=1, action=action)

        mapping_series = self.property_mapping("Series", "Program", psid, ppid, sequence=episode.serial_num,
                                               action=action)

        mapping_package = self.property_mapping("Package", "Program", "BP8168", ppid, sequence=episode.serial_num,
                                                action=action)
        return {
            "domain": "2",
            "object_list": [p_program, p_movie, p_program_picture],
            "mapping_list": [mapping_series, mapping_movie, mapping_program_picture, mapping_package],
        }

    def album(self, _header_id, action="REGIST"):
        header_id, _ = _header_id.split("_", 1)
        info_sync = MediaInfoSyncModel.objects.filter(pk=header_id).select_related("media").first()
        media = info_sync.media
        media_ext = media.mediaextfieldmodel
        data = self._album_series_header(media, media_ext, info_sync)
        xml = Adi.to_xml(data, flag="Nope")
        return xml

    def program(self, _task_id, action="REGIST"):
        task_id, _ = _task_id.split("_", 1)
        task = TaskModel.objects.filter(pk=task_id).select_related("storage").first()
        media_storage = task.storage  # 媒介
        media = media_storage.media  # 媒体文件主体
        episode = media_storage.episode  # (分集)扩展信息
        media_ext = media.mediaextfieldmodel  # 媒体文件补充信息

        _episodes = int(media.episodes) if media.episodes else 0
        if _episodes > 1:
            data = self._album_sub_series(media_storage, media, media_ext, episode, _episodes, action)
        else:  # 单剧集
            # data = self._album_movie(media_storage, media, episode, media_ext, action)
            data = self._album_sub_series(media_storage, media, media_ext, episode, _episodes, action)
        xml = Adi.to_xml(data, flag="Nope")
        return xml

    def exec_cmd(self, task_id):
        _task_id = self.generate_correlate_id(task_id)
        cmd_file_url = self.get_cmd_ftp_url(self.csp_id, _task_id)
        xml = C2ApiUtil.REQUESTXML.format(self.csp_id, self.lsp_id, "{}_{}".format(_task_id, datetime_now()),
                                          cmd_file_url)
        logger.warning("{} EXEC_CMD Request: {}".format(self.lsp_id, xml))
        headers = {"content-type": "text/xml", "SOAPAction": "application/soap+xml;charset=utf8"}
        response = requests.post(self.cms_api, data=xml, headers=headers).content
        logger.warning("{} EXEC_CMD Response: {}".format(self.lsp_id, response))
        tree = etree.fromstring(response)
        code = tree.find(".//Result").text
        desc = tree.find(".//ErrorDescription").text
        if int(code) == 0:
            status = TaskStatusValue.INFO_TRANSFERING
            remark = ""
        else:
            status = TaskStatusValue.INFO_FAILED
            remark = desc

        the_task = TaskModel.objects.filter(pk=task_id)
        if the_task.first().status in (TaskStatusValue.INFO_PENDING, TaskStatusValue.FILE_PENDING):
            the_task.update(status=status, remark=remark)
        return status

    def exec_sync_header_cmd(self, sync):
        _sync_id = self.generate_correlate_id(sync.id, stage="series")
        cmd_file_url = self.get_cmd_ftp_url(self.csp_id, _sync_id)
        sync_id = "{}_{}".format(_sync_id, datetime_now())

        xml = C2ApiUtil.REQUESTXML.format(self.csp_id, self.lsp_id, sync_id, cmd_file_url)
        logger.warning("{} exec_sync_header_cmd HEADER_ID: {}, Request: {}".format(self.lsp_id, sync.id, xml))
        headers = {"content-type": "text/xml", "SOAPAction": "application/soap+xml;charset=utf8"}
        try:
            response = requests.post(self.cms_api, data=xml, headers=headers).content
            logger.warning("{} exec_sync_header_cmd HEADER_ID: {}, Response: {}".format(self.lsp_id, sync.id, response))
            tree = etree.fromstring(response)
            code = tree.find(".//Result").text
            msg = "OK"
        except Exception as e:
            code = 400
            msg = str(e)
        if int(code) == 0:
            status = MediaInfoSyncModel.SYNCING
        else:
            status = MediaInfoSyncModel.FAILED
        the_sync = MediaInfoSyncModel.objects.filter(pk=sync.id)
        if the_sync.first().status == MediaInfoSyncModel.PENDING:
            the_sync.update(status=status, remark=msg)
        return

    def injector(self, task):
        status, flag = 0, 0
        if task.status in (TaskStatusValue.FILE_PENDING, TaskStatusValue.INFO_PENDING):
            _task_id = self.generate_correlate_id(task.id)
            self.save_album_xml_file(self.csp_id, _task_id, param="program")
            status = self.exec_cmd(task.id)
            flag = self.get_continue_to_injector(status)
        return status, flag

    def update(self, task):
        if task.status in (TaskStatusValue.FILE_PENDING, TaskStatusValue.INFO_PENDING):
            _task_id = self.generate_correlate_id(task.id)
            self.save_album_xml_file(self.csp_id, _task_id, param="program", action="UPDATE")
            self.exec_cmd(task.id)

    def remove(self, task):
        if task.status in (TaskStatusValue.FILE_PENDING, TaskStatusValue.INFO_PENDING):
            _task_id = self.generate_correlate_id(task.id)
            self.save_album_xml_file(self.csp_id, _task_id, param="program", action="DELETE")
            self.exec_cmd(task.id)
            self.off_line_storage(task.partner_id, task.storage_id)
            logger.warning("{} 下线媒体: {}, task_id: {}".format(self.partner_alias, task.storage_id, task.id))

    def series_header_injector(self, sync):
        if sync.status == MediaInfoSyncModel.PENDING:
            header_id = self.generate_correlate_id(sync.id, stage="series")
            self.save_album_xml_file(self.csp_id, header_id, param="series")
            self.exec_sync_header_cmd(sync)

    def series_header_update(self, sync):
        self.series_header_injector(sync)

    def series_header_remove(self, sync):
        self.series_header_injector(sync)

    def episode_no_header(self, media):
        print("category:{}".format(media.category))
        return media.category not in ("animation", "children", "movie")

    def build_head_xml(self, sync_id):
        header_id = self.generate_correlate_id(sync_id, stage="series")
        xml = self.album(header_id)
        filename = "120000000048_{}_00.xml".format(sync_id)
        p_dir = "D:\\test\\headers"
        file_path = os.path.join(p_dir, filename)
        with open(file_path, "w") as f:
            f.write(xml)

    def build_program_xml(self, task_id):
        header_id = self.generate_correlate_id(task_id, stage="series")
        xml = self.program(header_id)
        filename = "120000000048_{}_01.xml".format(task_id)
        p_dir = "D:\\test\\programs"
        file_path = os.path.join(p_dir, filename)
        with open(file_path, "w") as f:
            f.write(xml)

    def callback(self, request_body):
        logger.warning("{} 回执请求体内容 {}".format(self.partner_alias, request_body))
        params = C2ApiUtil.callback_params_config(self.partner_alias)
        re_correlate_id = params["correlate_id"]
        re_cmd_result = params["cmd_result"]
        re_result_file_url = params["result_fileURL"]
        re_response_xml = params["response_xml"]
        try:
            tree = ET.fromstring(request_body)
            cspId = tree.find(".//CSPID").text
            if cspId == "120000000117":
                domain = AnHuiZhongXing4K()
                return domain.callback(request_body)
            _correlate_id = tree.find(re_correlate_id).text
            code = tree.find(re_cmd_result).text
            result_file_url = tree.find(re_result_file_url).text
            cor_id, flag, _ = _correlate_id.split("_")
            text_flag = "剧头" if flag == "00" else "子集|电影"
            if cor_id:
                if flag == "00":
                    code, desc = self.callback_album(code, cor_id, result_file_url)
                else:
                    code, desc = self.callback_program(code, cor_id, result_file_url)
            else:
                logger.error(
                    "{} callback 回调错误, code:{}, {}: id: {}".format(self.partner_alias, code, cor_id, text_flag))
                code = -1
                desc = ResponseCode.PARAM_ERROR.desc
        except Exception:
            code, desc = -1, "未携带xml报文体,xml解析失败."
        xml = re_response_xml.format(desc, code)
        logging.warning("callback_response_xml:{}".format(xml))
        return xml
