from domain.injector.value_object import PlatformAliasValue
from domain.lsp.shanxiyidong_domain import ShanXiYiDong
import logging
import json
import xml.etree.ElementTree as ET
from injector.models import MediaInfoSyncModel, TaskModel

logger = logging.getLogger("django")


class CodeFactory:
    Series = "ps"  # 基础媒资信息id类别，供剧头使用
    Program = "p"
    Movie = "mv"  # 基础媒资分集id类别
    Image = "img"  # 基础媒资信息id类别
    Video = "video"
    C2 = "c2"
    STATUS_DELETE = "2"
    STATUS_REGISTER = "0"
    FLAG_SERIES = "00"
    FLAG_PROGRAM = "01"
    FLAG_SERIES_PROGRAM = "06"

    def get_flag_by_type(self, _type):
        if _type == self.Series:
            return self.FLAG_SERIES
        if _type in (self.Program, self.Movie):
            return self.FLAG_PROGRAM
        else:
            return self.FLAG_SERIES_PROGRAM

    def __init__(self, csp_code=""):
        self.csp_code = csp_code

    def gen_series_asset_id(self, series_id):
        flag_0 = (32 - len(str(series_id)) - len(self.Series) - len(self.csp_code) - 2) * "0"
        return "{}_{}{}_{}".format(self.Series, self.csp_code, flag_0, series_id)

    def gen_series_img_asset_id(self, series_id, flag="ver"):
        flag_0 = (32 - len(str(series_id)) - len(self.Series) - len(self.Image) - len(flag) - len(
            self.csp_code) - 5) * "0"
        return "{}_{}_{}_{}_{}_{}".format(self.Series, self.csp_code, self.Image, flag, flag_0, series_id)

    def gen_sub_asset_id(self, series_id, movie_id):
        flag_0 = (32 - len(str(series_id)) - len(str(movie_id)) - len(self.Program) - len(self.csp_code) - 3) * "0"
        return "{}_{}{}_{}_{}".format(self.Program, self.csp_code, flag_0, series_id, movie_id)

    def gen_sub_img_asset_id(self, series_id, movie_id, flag="ver"):
        flag_0 = (32 - len(str(series_id)) - len(self.Program) - len(self.Image) - len(flag) - len(self.csp_code) - len(
            str(movie_id)) - 6) * "0"
        return "{}_{}_{}_{}_{}_{}_{}".format(self.Program, self.csp_code, self.Image, flag, flag_0, series_id, movie_id)

    def gen_sub_video_asset_id(self, series_id, movie_id):
        flag_0 = (32 - len(str(series_id)) - len(self.Program) - len(self.Video) - len(self.csp_code) - len(
            str(movie_id)) - 5) * "0"
        return "{}_{}_{}_{}_{}_{}".format(self.Program, self.csp_code, self.Video, flag_0, series_id, movie_id)

    def gen_movie_asset_id(self, series_id, movie_id):
        flag_0 = (32 - len(str(series_id)) - len(str(movie_id)) - len(self.Movie) - len(self.csp_code) - 3) * "0"
        return "{}_{}{}_{}_{}".format(self.Movie, self.csp_code, flag_0, series_id, movie_id)

    def gen_movie_video_asset_id(self, series_id, movie_id):
        flag_0 = (32 - len(str(series_id)) - len(self.Movie) - len(self.Video) - len(self.csp_code) - len(
            str(movie_id)) - 5) * "0"
        return "{}_{}_{}_{}_{}_{}".format(self.Movie, self.csp_code, self.Video, flag_0, series_id, movie_id)

    def gen_movie_img_asset_id(self, series_id, movie_id, flag="ver"):
        flag_0 = (32 - len(str(series_id)) - len(self.Movie) - len(self.Image) - len(self.csp_code) - len(
            str(movie_id)) - len(flag) - 6) * "0"
        return "{}_{}_{}_{}_{}_{}_{}".format(self.Movie, self.csp_code, self.Image, flag, flag_0, series_id, movie_id)

    def gen_serialNo(self, task_id, flag, op, date):
        return "{}_{}_{}_{}_{}".format(task_id, flag, op, PlatformAliasValue.SHANXIYIDONGGTCS, date)

    def gen_serial_c2_no(self, task_id, flag, op, date):  # 06 删除更新
        return "{}_{}_{}_{}_{}{}".format(task_id, flag, op, PlatformAliasValue.SHANXIYIDONGGTCS, self.C2, date)


# 定义山西移动的类
class ShanXiYiDongGtcS(ShanXiYiDong):

    def __init__(self, alias="SHANXIYIDONGGTCS"):
        super().__init__(alias)
        self.strategyId = "1080"
        self.code_factory = CodeFactory(self.cps_code)

    def callback(self, body):
        json_obj = json.loads(body)
        requestNo = json_obj.get("requestNo")
        code = json_obj.get("code")
        resultMsg = json_obj.get("resultMsg")
        assetId = json_obj.get("assetId")
        distrId = json_obj.get("distrId")
        resultMsg = resultMsg if resultMsg else "分发失败"
        logger.info("distribute_callback:{}".format(json_obj))
        task_id, flag, op, _ = requestNo.split("_")
        remark = distrId + resultMsg
        if flag == "00":
            MediaInfoSyncModel.objects.filter(id=task_id).update(remark=remark)
            if code == "SUCC" and int(op) == 2:
                sync = MediaInfoSyncModel.objects.filter(id=task_id).first()
                self.remove_header_injector(sync)
        elif flag == "01":
            self.update_task_info(task_id, None, remark)
            if code == "SUCC" and int(op) == 2:
                task = TaskModel.objects.filter(id=task_id).first()
                self.remove_injector(task)
        elif flag == self.code_factory.FLAG_SERIES_PROGRAM:
            # 删除的添加
            if code == "SUCC" and int(op) == 2:
                op = self.code_factory.STATUS_REGISTER
                _flag = self.code_factory.get_flag_by_type(assetId.split("_")[0])
                logger.info("删除成功，然后新增.op:{} flag:{}".format(op, _flag))
                self.distribute_task(task_id, assetId, op, flag)
                if _flag == self.code_factory.FLAG_SERIES:
                    MediaInfoSyncModel.objects.filter(id=task_id).update(remark=remark)
                elif _flag == self.code_factory.FLAG_PROGRAM:
                    self.update_task_info(task_id, None, remark)
        return {"code": 0, "msg": "success"}

    def callback_adi(self, body):
        logger.warning("callback_adi : {}".format(body))
        try:
            root = ET.fromstring(body)
            ser_no = root.get("serialNo")
            code = root.get("code")
            msg = root.get("msg")
            ottmsp = root.get("ottmspFlag")
            op = root.find(".//Asset").get("op")
            type = root.find(".//Asset").get("type")
            id = root.find(".//Asset").get("ID")
            logger.info(
                "adi serialNo:{} code:{} msg:{} ottmspFlag：{} op:{} type:{} ID:{}".format(ser_no, code, msg, ottmsp, op,
                                                                                          type, id))
            task_id, flag, op, platform, _ = ser_no.split("_")
            if flag == "00":
                status, desc = self.series_callback_adi(task_id, code, ottmsp, op, id, flag, body)
            elif flag == "01":
                status, desc = self.program_callback_adi(task_id, code, ottmsp, op, id, flag, body)
            elif flag == "02":
                status, desc = self.series_callback_adi_other(task_id, code, ottmsp, op, id, flag, body)

        except Exception as e:
            logger.error("adi 执行分发error:{}".format(e))
            status, desc = -1, "未携带xml报文体,xml解析失败."
        result = "{}|{}".format(status, desc)
        return result

    def callback_cdi(self, body):
        logger.warning("callback_cdi: {}".format(body))
        try:
            tree = ET.fromstring(body)
            attrib = tree.find(".//header").attrib
            code = attrib.get("code")
            msg = attrib.get("msg")
            sequence = attrib.get("sequence")
            componentid = attrib.get("component-id")
            serialNo = attrib.get("serialNo")
            action = attrib.get("action")
            asset_id = tree.find(".//task").attrib.get("original-content-id")
            logger.info(
                "code:{} msg:{} sequence：{} componentid:{} action:{} serialNo:{}".format(code, msg, sequence,
                                                                                         componentid, action, serialNo))
            task_id, flag, op, platform, _ = serialNo.split("_")
            if flag == "01":
                self.program_callback_cdi(task_id, code)
            elif flag == "03":
                self.program_callback_cdi_other()
            if int(code) == 0:
                # 准备分发
                if op != "2":
                    _code, _msg = self.distribute_task(task_id, asset_id, op, flag)
                    self.update_task_info(task_id, None, _msg)
            status = 1
            desc = "OK"
        except Exception as e:
            logger.info("cdi 执行分发error:{}".format(e))
            status, desc = 0, "fail"
        return status, desc
