from operator import contains
from django.core.paginator import Paginator
from domain.imdb.value_object import CategoryValue
from imdb.models import ProductMedia
from origin.models import VideoMeta


class MetaMedia:
    model = ProductMedia

    @classmethod
    def search(cls, name):
        product_media = cls.model.objects.values("id", "name").distinct().filter(name__icontains=name, hidden=False)
        return product_media

    @classmethod
    def search_name_by_id(cls, string_ids):
        ids = [int(temp.strip()) for temp in string_ids.split(',')]
        return list(cls.model.objects.values("id", "name").distinct().filter(id__in=ids))

    # 解析数据整合
    @classmethod
    def parse_data(cls, data):
        params = {
            "name": data.get("name", None),
            "alias": data.get("alias", None),
            "type": data.get("type", '0'),
            "theme": data.get("theme", None),
            "episodes": int(data.get("episodes")) if data.get("episodes") else None,
            "episodes_time": float(data.get("episodes_time")) if data.get("episodes_time") else None,
            "total_time": float(data.get("total_time")) if data.get("total_time") else None,
            "play_app": data.get("play_app", None),
            "play_time": data.get("play_time") if data.get("play_time") else None,
            "production_time": data.get("production_time", None),
            "area": data.get("area", None),
            "plots": data.get("plots", None),
            "same_with": int(data.get("same_with")) if data.get("same_with") else None,
            "hidden": data.get("hidden", None),
            "actor": data.get("actor", None),
            "writers": data.get("writers", None),
            "director": data.get("director", None),
            "make_company": data.get("make_company", None),
            "publish_licence": data.get("publish_licence", None),
            "rater": data.get("rater", None),
            "sparkle": data.get("sparkle", None),
            "image": data.get("image", None),
            "age_group": data.get("age_group", None),
            "audience_group": data.get("audience_group", None),
            "extension": data.get("extension", None),
            "create_time": data.get("create_time", None),
        }
        return {k: v for k, v in params.items() if v is not None}

    # 资产系统同步信息
    def synchronous(self, _id, kwargs):
        # 更新合并前的媒体信息
        obj, _ = self.model.objects.update_or_create(defaults=kwargs, id=int(_id))
        # 由于合并媒体hidden是True，而关联媒体的hidden是False，所以剔除掉该参数
        kwargs.pop("hidden", None)
        same_with = kwargs.pop("same_with", None)
        if same_with:
            # 关联新媒体
            self.model.objects.update_or_create(defaults=kwargs, id=int(same_with))
        return obj.id, same_with

    # 关联源视频
    @classmethod
    def _related_video_meta(cls, hidden_id, related_id):
        VideoMeta.objects.filter(media_id=hidden_id).update(media_id=related_id)
        return

    # 变更系统关联信息: 源视频关联、等
    def related(self, hidden_id, related_id):
        """
        :param hidden_id: 待合并的资产媒体id
        :param related_id: 关联新资产媒体id
        :return:
        """
        if related_id:
            # 源视频关系重新定义
            self._related_video_meta(int(hidden_id), int(related_id))
            # 后续补充其它的
        return

    @staticmethod
    def to_dict(product_media):
        result = {
            'id': product_media.id,
            'name': product_media.name,
            'alias': product_media.alias,
            'category': product_media.get_channel(),
            'date_published': product_media.play_time,
            'douban_score': product_media.rater,
            'episodes': product_media.episodes,
            'img': product_media.image,
            'storyline': product_media.plots,
            'year': product_media.production_time.replace('年', ''),
            'create_time': product_media.create_time,
            'genre': product_media.theme,
            'region': product_media.area,
            'minutes': product_media.episodes_time,
            'total_minutes': product_media.total_time,
            'languages': '',
            'is_update': 1 if product_media.synchronous else 0
        }

        return result

    @classmethod
    def _get_list(cls, query_set, page=1, page_size=20):
        pager = Paginator(query_set, page_size)
        product_media_list = pager.get_page(page)
        resp_media = []
        for product_media in product_media_list:
            _product_media = cls.to_dict(product_media)
            resp_media.append(_product_media)

        data = {
            'total_page': pager.num_pages,
            'product_media_list': resp_media
        }
        return data

    @classmethod
    def get_list(cls, page=1, page_size=20):
        query = cls.model.objects.filter(hidden=0).all().order_by('-id')
        return cls._get_list(query, page, page_size)

    @classmethod
    def search_product_medias(cls, page=1, page_size=20, **kwargs):
        if not kwargs:
            return cls.get_list(page, page_size)

        query_data = {}
        if kwargs['name']:
            query_data['name__icontains'] = kwargs['name']

        if kwargs['area']:
            query_data['area'] = kwargs['area']

        if kwargs['category']:
            query_data['type'] = ProductMedia().type_dict.get(kwargs['category'])

        if kwargs['is_update']:
            query_data['synchronous'] = kwargs['is_update']

        if kwargs['start_year'] and kwargs['end_year']:
            if kwargs['start_year'] == kwargs['end_year']:
                query_data.update({'production_time': kwargs['start_year']})
            else:
                query_data.update({
                    'production_time__gte': kwargs['start_year'],
                    'production_time__lte': kwargs['end_year']
                })

        query_set = cls.model.objects.filter(**query_data).filter(hidden=0).order_by("-id")

        return cls._get_list(query_set, page, page_size)

    @classmethod
    def get_product_media_by_id(cls, pk):
        return cls.model.objects.get(id=pk)