import logging

from django.core.paginator import Paginator

import domain.injector.factory
from imdb.models import MediaModel, EpisodeModel, CelebrityMediaRelationModel, CelebrityModel, GenreModel
from injector.models import MediaInfoSyncModel, MediaExtFieldModel, LSP, TaskModel
from domain.injector import factory
from domain.dataset import DataSet

from utils import date_utils
from utils.exception import ParamError


class MediaSyncInfo(DataSet):
    model = MediaInfoSyncModel

    @classmethod
    def add(cls, partner_id, media_id):
        partner_domain = factory.create_by_id(partner_id)
        partner_domain.check_series_header_args(media_id)
        media = MediaModel.objects.get(id=media_id)
        # remark = partner_domain.get_media_name_by_alias(media)
        origin_name = partner_domain.get_media_name_by_alias(media)
        sync = cls.model.objects.create(media_id=media_id, partner_id=partner_id, remark="", origin=origin_name)
        # 剧头创建成功直接执行注入
        partner_domain.series_header_injector(sync)
        return

    @classmethod
    def series_is_exist(cls, media_id, partner_id):
        len_sync = cls.model.objects.filter(media_id=media_id, partner_id=partner_id).exists()
        if len_sync:
            raise ParamError("请勿重复发起剧头任务")
        return len_sync

    @classmethod
    def search(cls, media_name, lsp_id, status, page=1, page_size=20, lsp_ids=None):
        query = dict()
        if media_name:
            query["media__name__icontains"] = media_name
        if lsp_id:
            query["partner_id"] = int(lsp_id)
        if int(status) >= 0:
            query["status"] = status
        if lsp_ids:
            query["partner_id__in"] = lsp_ids
        query_set = cls.model.objects.filter(**query).select_related("media")
        data = cls._get_list(query_set, page, page_size)
        return data

    @staticmethod
    def to_dict(item):
        # psid = "暂无"
        partner_domain = factory.create_by_id(item.partner_id)
        # if partner_domain.partner_alias == "ANHUIDIANXINXIN":
        psid = partner_domain.gen_series_code_by_media(item.media_id)
        is_show = 1
        if item.status == MediaSyncInfo.model.PENDING:
            is_show = 0
        if item.action == MediaSyncInfo.model.DELETE:
            is_show = 0

        data = {
            'id': item.id,
            'lsp_id': item.partner_id,
            'lsp_name': item.partner.name,
            'media_id': item.media_id,
            'media_name': item.media.name,
            'origin_name': item.origin,
            'state': item.state_description(),
            'remark': item.remark,
            'action': item.action_description(),
            'is_show': is_show,
            'category': item.media.category,
            'create_time': date_utils.dt_format(item.create_time),
            'update_time': date_utils.dt_format(item.update_time),
            "info": "{}".format(psid),
        }
        return data

    @classmethod
    def _get_list(cls, query, page, page_size):
        query = query.order_by("-id")
        pager = Paginator(query, page_size)
        obj_list = pager.get_page(page)
        result = [cls.to_dict(obj) for obj in obj_list]
        data = {
            "total_page": pager.num_pages,
            "data_list": result,
            "total_item": pager.count
        }
        return data

    def update(self, query_info, update_info):
        self.model.objects.filter(**query_info).update(**update_info)

    @classmethod
    def handler_category(cls, category_id, action="REGIST"):
        lsp = LSP.objects.filter(alias="NEIMENGYDIPTV").first()
        partner_id = lsp.id

        genre = GenreModel.objects.filter(pk=category_id).first()
        sync = MediaInfoSyncModel.objects.filter(partner_id=partner_id).first()
        partner_domain = factory.create_by_id(partner_id)
        # 剧头创建成功直接执行注入
        parent_genre = None
        if genre.parent:
            parent_genre = GenreModel.objects.filter(pk=genre.parent).first()
        partner_domain.injector_category_handler(sync, genre, parent_genre, action)

    @classmethod
    def handler_package(cls, package_id, action="REGIST"):
        lsp = LSP.objects.filter(alias="NEIMENGYDIPTV").first()
        partner_id = lsp.id

        sync = MediaInfoSyncModel.objects.filter(partner_id=partner_id).first()
        partner_domain = factory.create_by_id(partner_id)
        # # 剧头创
        # parent_genre = None
        # if genre.parent:
        #     parent_genre = GenreModel.objects.filter(pk=genre.parent).first()
        partner_domain.injector_package_handler(sync, sync, package_id, action)

    @classmethod
    def handler_category_bind(cls, head_id, category_id, action="REGIST"):
        lsp = LSP.objects.filter(alias="NEIMENGYDIPTV").first()
        partner_id = lsp.id
        partner_domain = factory.create_by_id(partner_id)
        sync = MediaInfoSyncModel.objects.filter(id=head_id).first()
        logging.warning("head_id:{}, category_id:{}".format(head_id, category_id))
        genre = GenreModel.objects.filter(pk=category_id).first()
        logging.warning("genre:{}".format(genre.name))
        parent_genre = GenreModel.objects.filter(pk=genre.parent).first()
        partner_domain.bind_task_category_handler(sync, genre, parent_genre, action)

    @classmethod
    def handler_task_category_bind(cls, task_id, category_id, action="REGIST"):
        lsp = LSP.objects.filter(alias="NEIMENGYDIPTV").first()
        partner_id = lsp.id
        partner_domain = factory.create_by_id(partner_id)
        task = TaskModel.objects.filter(id=task_id).first()
        genre = GenreModel.objects.filter(pk=category_id).first()

        parent_genre = GenreModel.objects.filter(pk=genre.parent).first()
        partner_domain.bind_task_category_handler(task, genre, parent_genre, action)