#! /usr/bin/env python3
# -*- coding:utf-8 -*-

import subprocess
import json
import math
import logging
from django.core.paginator import Paginator
from domain.dataset import DataSet
from origin.models import VideoMeta
from origin.models import UploadServer
from perm.service.user_service import UserService
from django.conf import settings
from utils.decorators import cache_result
from utils.queue_producer import enqueue, query
from apollo.settings import DELETE_ORIGIN_VIDEO

logger = logging.getLogger(__file__)


class MetaVideo(DataSet):
    model = VideoMeta
    cache_key = "video_type"

    @classmethod
    def add(cls, url, name, md5, media_id, episode, uid, data):
        prefix, suffix = url.split("/matrix/", 1)
        ip = prefix.split("//", 1)[-1].split(":", 1)[0]
        path = UploadServer.get_prefix_url(ip, suffix)

        video_info = {}

        if not name:
            name = url.split("/")[-1]

        video_info.update({
            "name": name,
            "path": path,
            "md5": md5,
            "episode": episode,
            "media_id": int(media_id),
            "create_user": uid,
            "v_codec": data.get("v_codec"),
            "v_profile": data.get("v_profile"),
            "width": data.get("width"),
            "height": data.get("height"),
            "v_bit_rate": data.get("v_bit_rate"),
            "sample_aspect_ratio": data.get("sample_aspect_ratio"),
            "display_aspect_ratio": data.get("display_aspect_ratio"),
            "seconds": data.get("seconds"),
            "a_codec": data.get("a_codec"),
            "a_channels": data.get("a_channels"),
            "a_bit_rate": data.get("a_bit_rate"),
            "a_sample_rate": data.get("a_sample_rate"),
            "bit_rate": data.get("bit_rate"),
            "size": data.get("size"),
            "dub": data.get("dub", "0"),
            # "frame_rate": data.get("frame_rate", 0)
        })

        cls.model.objects.create(**video_info)
        return

    @classmethod
    def delete(cls, vid):
        cls.model.objects.filter(pk=vid).update(is_delete=True)
        return

    @classmethod
    def _get_list(cls, query, page, page_size):
        pager = Paginator(query, page_size)
        obj_list = pager.get_page(page)
        data_list = []
        for i in obj_list:
            product_media = {
                "id": i.media_id,
                "name": i.media.name
            }
            meta_video = cls.to_dict(i)
            if len(meta_video["sample_aspect_ratio"]) > 3:
                _left, _right = meta_video["sample_aspect_ratio"].split(":")
                left, right = int(round(int(_left) / int(_right), 1) * 10), 10
                meta_video["sample_aspect_ratio"] = "{}:{}".format(left, right)
            if len(meta_video["display_aspect_ratio"]) > 7:
                _left, _right = meta_video["display_aspect_ratio"].split(":")
                left, right = int(round(int(_left) / int(_right), 2) * 100), 100
                meta_video["display_aspect_ratio"] = "{}:{}".format(left, right)
            meta_video["media"] = product_media
            data_list.append(meta_video)
        data = {
            "total_page": pager.num_pages,
            "data_list": data_list,
        }
        return data

    @classmethod
    @cache_result(settings.EXPIRE_TIME, cache_key)
    def _load_from_db(cls):
        items = cls.model.objects.all().values("v_codec").distinct()
        return list(items)

    @classmethod
    def get_video_type(cls):
        return cls._load_from_db()

    @classmethod
    def get_list(cls, uid, is_show_all=0, page=1, page_size=20, **kwargs):
        query_data = {"is_delete": False}
        if not is_show_all:
            if not UserService().is_admin(uid):
                query_data["create_user"] = uid

        if kwargs["name"]:
            query_data["name__icontains"] = kwargs["name"]

        if kwargs["m_name"]:
            query_data["media__name__icontains"] = kwargs["m_name"]

        if kwargs["episode"]:
            query_data["episode"] = kwargs["episode"]

        if kwargs["v_codec"]:
            query_data["v_codec"] = kwargs["v_codec"]

        if query_data:
            query = cls.model.objects.filter(**query_data).order_by("-id")
        else:
            query = cls.model.objects.all().order_by("-id")

        return cls._get_list(query, page, page_size)

    @classmethod
    def update(cls, meta_id, name, episode, product_media_id):
        _params = {
            "name": name,
            "episode": episode,
            "media_id": product_media_id
        }
        params = {k: v for k, v in _params.items() if v}
        if meta_id:
            cls.model.objects.filter(id=meta_id).update(**params)
        return

    @classmethod
    def bulk_delete_meta_video(cls, meta_ids):
        """ 批量删除源视频 """
        for meta_id in meta_ids:
            meta_video = cls.model.objects.select_related("media").filter(pk=meta_id).first()
            cls.delete(meta_id)
            stream_data = {"m_id": meta_video.media_id, 'path': meta_video.path, 'name': meta_video.name,
                           'm_name': meta_video.media.name,
                           'type': meta_video.media.get_channel()}
            print("stream_data:{}".format(stream_data))
            enqueue(DELETE_ORIGIN_VIDEO, stream_data)

    @classmethod
    def query_delete_meta_video(cls, key):
        data = query(key)
        print("data_type:{}".format(type(data)))
        return data