import logging

from domain.injector.value_object import DefinitionValue
from domain.lsp.ningxiayidong_domain import NingXiaYiDong
from domain.lsp.value_object import CodeFactory


logger = logging.getLogger(__file__)


class HaiNanYiDong(NingXiaYiDong):

    def __init__(self, alias="HAINANYIDONG"):
        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.region_sep = "|"
        self.genre_sep = "|"
        self.tag_sep = ","

    def _get_bit_rate_type(self, definition):
        if definition == DefinitionValue.P320:
            return 2
        elif definition == DefinitionValue.P480:
            return 3
        elif definition == DefinitionValue.P720:
            return 4
        elif definition == DefinitionValue.P1080:
            return 4
        elif definition == DefinitionValue.K4:
            return 4
        return 3

    def _have_episode_title(self, media, episode):
        fmt = "{0}{1}{2}"
        return fmt.format(self.get_media_name_by_alias(media), "_", episode.serial_num)

    def property_series(self, _id, volumn_count, media, action="REGIST"):
        the_property = [
            {"Name": self.get_media_name_by_alias(media)},
            {"Language": media.languages},
            {"VolumnCount": volumn_count},
            {"ReleaseYear": media.year},
            {"OriginalCountry": self.get_regions(media)},
            {"Score": media.douban_score},
            {"Description": media.storyline},
            {"Duration": int(media.total_seconds / 60) + 1},
            {"ContentType": "Video"},
            {"IfPreview": 0}
        ]
        return {
            "element_type": "Series",
            "id": _id,
            "code": _id,
            "action": action,
            "property": the_property
        }

    def property_program(self, _id, name, media, action="REGIST"):
        return {
            "element_type": "Program",
            "id": _id,
            "code": _id,
            "action": action,
            "property": [{"Name": name}]
        }

    def property_movie(self, _id, media_storage, _type=1, action="REGIST"):
        cdn_ids = self.csp_name.split(self.tag_sep)
        the_property = [
            {"FileURL": media_storage.url},
            {"PlayURL": media_storage.url},
            {"CdnPlatform": self.csp_name},
            {"Dispatch": "1"},
            {"IsTranscode": 0},
            {"Md5": media_storage.md5},
            {"extInfo": '![CDATA[ {} ]]'.format(
                {"cdnPlayInfos": [{"cdnId": int(cdn_id), "playUrl": media_storage.url} for cdn_id in cdn_ids]}
            )}
        ]
        return {
            "element_type": "Movie",
            "id": _id,
            "code": _id,
            "action": action,
            "property": the_property
        }

    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_media_effective_time(media.id)
        _episodes = int(media.episodes) if media.episodes else 0
        param_dict = {"category": media.category, "is_charge": 1}
        change_fields = self.injected_change.get_injected_fields(media.id, self.lsp_pk, param_dict)
        definition = self._get_bit_rate_type(media_storage.definition)
        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)
        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)
        p_series = self.property_series(psid, _episodes, media, action=action)
        p_series["property"].extend([
            {"ActorDisplay": actors},
            {"WriterDisplay": writers},
            {"ScriptWriter": directors},
            {"Definition": definition},
            {"PictureURL1": self.to_ip_url(media_verpic)},
            {"HorizontalPoster": self.to_ip_url(media_horpic)},
            {"ProgramType": self._get_category_desc(change_fields["category"])},
            {"ProgramType2": self.get_genre(media)},
            {"IsCharge": str(change_fields["is_charge"])},
            {"Recommendation": media_ext.focus},
            {"CopyRightBeginDate": vst},
            {"CopyRightEndDate": vet}
        ])

        ppid = self.code_factory.gen_program_code(media_storage.id)
        p_program = self.property_program(ppid, self.get_media_name_by_alias(media), media, action=action)
        p_program["property"].extend([
            {"VolumnCount": episode.serial_num},
            {"ProgramType": self._get_category_desc(change_fields["category"])},
            {"ProgramType2": self.get_genre(media)},
            {"IsCharge": str(change_fields["is_charge"])},
            {"Definition": definition},
            {"PictureURL1": self.to_ip_url(episode_horpic)},
            {"IsCharge": str(change_fields["is_charge"])},
            {"Seriesflag": 0},
            {"Description": episode.storyline}
        ])
        mapping_program = self.property_mapping("Series", "Program", psid, ppid, sequence=episode.serial_num, action=action)

        pmid = self.code_factory.gen_movie_code(media_storage.id)
        p_movie = self.property_movie(pmid, media_storage, action=action)
        p_movie["property"].extend([{"Definition": definition}])
        mapping_movie = self.property_mapping("Program", "Movie", ppid, pmid, action=action)

        return {
            "object_list": [p_series, p_program, p_movie],
            "mapping_list": [mapping_program, mapping_movie]
        }

    def _album_series_header(self, media, media_ext, info_sync):
        action = info_sync.action_description()
        actors, directors, writers = self.get_media_person(media, actor=4, director=4, writer=2)
        vst, vet = self.get_media_effective_time(media.id)
        _episodes = int(media.episodes) if media.episodes else 0
        param_dict = {"category": media.category, "is_charge": 1}
        change_fields = self.injected_change.get_injected_fields(media.id, self.lsp_pk, param_dict)
        # 海南方要求剧头注入时 要填写清晰度，默认为高清
        definition = 1
        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)
        p_series = self.property_series(psid, _episodes, media, action=action)
        p_series["property"].extend([
            {"ActorDisplay": actors},
            {"WriterDisplay": writers},
            {"ScriptWriter": directors},
            {"Definition": definition},
            {"PictureURL1": self.to_ip_url(media_verpic)},
            {"HorizontalPoster": self.to_ip_url(media_horpic)},
            {"ProgramType": self._get_category_desc(change_fields["category"])},
            {"ProgramType2": self.get_genre(media)},
            {"IsCharge": str(change_fields["is_charge"])},
            {"Recommendation": media_ext.focus},
            {"CopyRightBeginDate": vst},
            {"CopyRightEndDate": vet}
        ])

        return {
            "object_list": [p_series],
            "mapping_list": []
        }

    def _album_sub_series(self, media_storage, media, episode, _episodes, action="REGIST"):
        episode_title = self.get_episode_title(media, episode)
        param_dict = {"category": media.category, "is_charge": 1}
        change_fields = self.injected_change.get_injected_fields(media.id, self.lsp_pk, param_dict)
        definition = self._get_bit_rate_type(media_storage.definition)
        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)

        ppid = self.code_factory.gen_program_code(media_storage.id)
        p_program = self.property_program(ppid, episode_title, media, action=action)
        p_program["property"].extend([
            {"VolumnCount": episode.serial_num},
            {"ProgramType": self._get_category_desc(change_fields["category"])},
            {"ProgramType2": self.get_genre(media)},
            {"IsCharge": str(change_fields["is_charge"])},
            {"Definition": definition},
            {"PictureURL1": self.to_ip_url(episode_horpic)},
            {"IsCharge": str(change_fields["is_charge"])},
            {"Description": episode.storyline},
            {"Seriesflag": 0}
        ])
        mapping_program = self.property_mapping("Series", "Program", psid, ppid, sequence=episode.serial_num, action=action)

        pmid = self.code_factory.gen_movie_code(media_storage.id)
        p_movie = self.property_movie(pmid, media_storage, action=action)
        p_movie["property"].extend([{"Definition": definition}])
        mapping_movie = self.property_mapping("Program", "Movie", ppid, pmid, action=action)

        return {
            "object_list": [p_program, p_movie],
            "mapping_list": [mapping_program, mapping_movie],
        }