# -*- coding: utf-8 -*-
# @Time: 2023/12/26
import datetime
import random
import os
import re
import sys
import time
import resource
import requests
import urllib.parse

from moviepy.video.compositing.concatenate import concatenate

sys.path.append(os.getcwd())
from datetime import datetime
from common import Feishu
from common.aliyun_oss_uploading import Oss
from common.common import Common
from common.db import MysqlHelper
from common.material import Material
from moviepy.editor import concatenate_videoclips
from moviepy.video.io.VideoFileClip import VideoFileClip
from moviepy import editor




output_path = "./video_stitching/video/new_video.mp4"
class VideoStitching():

    @classmethod
    def split_text(cls, text, max_length):
        words = text.split(' ')
        lines = []
        current_line = ''
        for word in words:
            if len(current_line) + len(word) <= max_length:
                current_line += word + ' '
            else:
                lines.append(current_line.strip())
                current_line = word + ' '
        lines.append(current_line.strip())
        result = ''.join(lines)
        result = result[:11] + '\n' + result[11:]  # 在第10个字后面增加换行
        return result

    @classmethod
    def srt_to_seconds(cls,srt_time):
        hours, minutes, seconds = map(float, srt_time.replace(',', '.').split(':'))
        return hours * 3600 + minutes * 60 + seconds

    @classmethod
    def insert_videoAudio(cls, audio_url, i):
        current_time = datetime.now()
        formatted_time = current_time.strftime("%Y-%m-%d")
        for j in audio_url:
            insert_sql = f"""INSERT INTO video_audio (audio, video_id, account_id, oss_object_key, time) values ('{i}', '{j[0]}', '{j[1]}', '{j[2]}', '{formatted_time}')"""
            MysqlHelper.update_values(
                sql=insert_sql,
                env="prod",
                machine="",
            )



    @classmethod
    def insert_video_typeAudio(cls, video, audio_id):
        current_time = datetime.now()
        formatted_time = current_time.strftime("%Y-%m-%d")
        insert_sql = f"""INSERT INTO video_audio (audio, account_id, oss_object_key, time) values ('{audio_id}', '{video}', '{video}', '{formatted_time}')"""
        MysqlHelper.update_values(
            sql=insert_sql,
            env="prod",
            machine="",
        )

    # 随机生成id
    @classmethod
    def random_id(cls):
        now = datetime.now()
        rand_num = random.randint(10000, 99999)

        id = "{}{}".format(now.strftime("%Y%m%d%H%M%S"), rand_num)
        return id

    @classmethod
    def get_account_id(cls):
        account_id = f"""select account_id from video_url group by account_id;"""
        account_id = MysqlHelper.get_values(account_id, "prod")
        return account_id

    @classmethod
    def get_audio_list(cls):
        audio_list = f"""select oss_object_key from video_koubo_url;"""
        audio_list = MysqlHelper.get_values(audio_list, "prod")
        return audio_list


    @classmethod
    def get_url_list(cls, audio_id, account):
        url_list = f"""SELECT a.video_id,a.account_id,a.oss_object_key FROM video_url a WHERE NOT EXISTS (
                SELECT video_id
                FROM video_audio b
                WHERE a.video_id = b.video_id AND b.audio = '{audio_id}'
            ) AND a.account_id = {account}  limit 35;"""
        url_list = MysqlHelper.get_values(url_list, "prod")
        return url_list

    @classmethod
    def get_audio_url_list(cls, choice_audio, audio_id):
        url_list = f"""SELECT audio FROM  video_audio where audio = '{audio_id}' and oss_object_key = '{choice_audio}';"""
        url_list = MysqlHelper.get_values(url_list, "prod")
        return url_list

    # 新生成视频上传到对应账号下
    @classmethod
    def insert_piaoquantv(cls, oss_object_key, title_list):
        code = 1
        list = ["66481136", "66481137", "66481140", "66481141", "66481142"]
        for i in range(2):
            item = random.choice(list)
            title_list = [item for item in title_list if item is not None]
            title = random.choice(title_list)
            # title = title[0].strip("[]'")
            url = "https://vlogapi.piaoquantv.com/longvideoapi/crawler/video/send"
            payload = dict(pageSource='vlog-pages/post/post-video-post', videoPath=oss_object_key, width='720',
                           height='1280', fileExtensions='mp4', viewStatus='1', title=title, careModelStatus='1',
                           token='f04f58d6e664cbc9902660a1e8d20ce6cd7fdb0f', loginUid=item, versionCode='719',
                           machineCode='weixin_openid_o0w175aZ4FJtqVsA1tcozJDJHdDU', appId='wx89e7eb06478361d7',
                           clientTimestamp='1703337579331',
                           machineInfo='{"sdkVersion":"3.2.5","brand":"iPhone","language":"zh_CN","model":"iPhone 12 Pro<iPhone13,3>","platform":"ios","system":"iOS 15.6.1","weChatVersion":"8.0.44","screenHeight":844,"screenWidth":390,"pixelRatio":3,"windowHeight":762,"windowWidth":390,"softVersion":"4.1.719"}',
                           sessionId='1703337560040-27bfe208-a389-f476-db1d-840681e04b32',
                           subSessionId='1703337569952-8f56d53c-b36d-760e-8abe-0b4a027cd5bd', senceType='1089',
                           hotSenceType='1089', id='1050', channel='pq')

            payload['videoPath'] = oss_object_key
            payload['title'] = title

            data = urllib.parse.urlencode(payload)

            headers = {
                'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 15_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 MicroMessenger/8.0.44(0x18002c2d) NetType/WIFI Language/zh_CN',
                'Accept-Encoding': 'gzip,compress,br,deflate',
                'Referer': 'https://servicewechat.com/wx89e7eb06478361d7/726/page-frame.html',
                'Content-Type': 'application/x-www-form-urlencoded',
                'Cookie': 'JSESSIONID=A60D96E7A300A25EA05425B069C8B459'
            }

            response = requests.post(url, data=data, headers=headers)
            data = response.json()
            code = data["code"]
        if code == 0:
            return True
        else:
            return False


    # 视频拼接
    @classmethod
    def concatenate_videos(cls, videos, audio, srt, type_audio):
        clips = []
        total_duration = 0
        included_videos = []
        # 设置最大可使用的内存限制（单位：字节）
        memory_limit = 6 * 1024 * 1024 * 1024  # 6GB
        resource.setrlimit(resource.RLIMIT_AS, (memory_limit, memory_limit))
        # 提取视频的音频
        Common.logger().info(f"开始提取视频的音频{audio}")
        video1 = VideoFileClip(audio)
        mp3 = video1.audio
        Common.logger().info(f"提取视频的音频成功")

        # 获取音频时长（以秒为单位）
        duration_limit = mp3.duration
        if type_audio == "口播--美文类":
            # 读取视频文件，获取视频时长
            clip = f"https://art-crawler.oss-cn-hangzhou.aliyuncs.com/{videos[0]}"
            clip = VideoFileClip(clip)
            video_duration = clip.duration
            # 计算需要循环播放的视频个数
            n_videos = int(duration_limit / video_duration) + 1
            # 循环生成视频剪辑
            video_clips = [clip] * n_videos
            # 连接视频剪辑
            final_clip = concatenate(video_clips, method="compose")
            # 设置最终剪辑的时长与音频时长一致
            final_clip = final_clip.set_duration(duration_limit)
        else:
            # 遍历每个视频并计算总时长
            for i, video in enumerate(videos):
                clip = VideoFileClip(f"https://art-crawler.oss-cn-hangzhou.aliyuncs.com/{video[2]}")
                clips.append(clip)
                total_duration += clip.duration
                if total_duration >= duration_limit:
                    break

            # 如果总时长小于等于目标时长，则不做视频拼接
            if total_duration <= duration_limit:
                Common.logger().info(f"时长小于等于目标时长，不做视频拼接")
                # 关闭视频文件
                for clip in clips:
                    clip.close()
                return ""
            else:
                Common.logger().info(f"总时长大于目标时长")
                remaining_time = duration_limit
                final_clips = []

                for clip, video in zip(clips, videos):
                    if remaining_time - clip.duration >= 0:
                        final_clips.append(clip)
                        included_videos.append(video)
                        remaining_time -= clip.duration
                    else:
                        # 如果剩余时间不足以加入下一个视频，则截断当前视频并返回已包含的URL
                        final_clips.append(clip.subclip(0, remaining_time))
                        included_videos.append(video)
                        break
                final_clip = concatenate_videoclips(final_clips)
        final_clip = final_clip.set_audio(mp3)
        # 统一设置视频分辨率
        final_width = 320
        final_height = 480
        final_clip = final_clip.resize((final_width, final_height))
        # 设置背景色
        color_clip = editor.ColorClip(size=(final_width, 90),
                                      color=(255, 255, 0)).set_duration(duration_limit)
        final_clip = editor.CompositeVideoClip([final_clip, color_clip.set_position(("center", final_height - 80))])
        Common.logger().info(f"字幕内容为：{srt}")
        if srt != None:
            Common.logger().info(f"处理字幕文件")
            # 使用正则表达式提取时间码和字幕内容
            pattern = r"(\d{2}:\d{2}:\d{2},\d{3}) --> (\d{2}:\d{2}:\d{2},\d{3})\n([\s\S]+?(?=\n\d|$))"
            matches = re.findall(pattern, srt)
            Common.logger().info(f"字幕{matches}")
            # 获取字幕
            subtitle_clips = []
            for match in matches:
                start = editor.cvsecs(cls.srt_to_seconds(match[0]))
                end = editor.cvsecs(cls.srt_to_seconds(match[1]))
                text = match[2].strip()
                text = cls.split_text(text, 10)
                # /System/Library/Fonts/Hiragino Sans GB.ttc 本地字体
                # /usr/share/fonts/truetype/wqy/wqy-zenhei.ttc 服务器地址
                Common.logger().info(f"字幕:{text}")
                sub = editor.TextClip(text, font="/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",
                                      fontsize=18, color="black").set_duration(end - start).set_start(
                    start).set_position(
                    ("center", final_height - 60)).set_opacity(0.8)
                subtitle_clips.append(sub)
            Common.logger().info(f"将字幕添加到视频上")
            # 将字幕添加到视频上
            video_with_subtitles = editor.CompositeVideoClip([final_clip] + subtitle_clips)
        else:
            Common.logger().info(f"添加固定字幕")
            text_clip = (
                editor.TextClip("分享、转发给群友", font="/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",
                                fontsize=30, color="black").
                    set_position(("center", final_height - 70)).
                    set_duration(duration_limit).
                    set_opacity(0.8)
            )
            # 把 `文本剪贴板` 贴在视频上
            video_with_subtitles = editor.CompositeVideoClip([final_clip, text_clip])
        # 生成视频
        video_with_subtitles.write_videofile(output_path, fps=35)
        if os.path.isfile(output_path):
            Common.logger().info("视频生成成功！生成路径为:", output_path)
            return included_videos, video_with_subtitles, clips
        else:
            Common.logger().info("视频生成失败，请检查代码和文件路径。")
            return "", video_with_subtitles, clips


    @classmethod
    def get_audio_url(cls, i, cookie):
        url = f"https://admin.piaoquantv.com/manager/video/detail/{i}"

        payload = {}
        headers = {
            'authority': 'admin.piaoquantv.com',
            'accept': 'application/json, text/plain, */*',
            'accept-language': 'zh-CN,zh;q=0.9',
            'cache-control': 'no-cache',
            'cookie': cookie,
            'pragma': 'no-cache',
            'referer': f'https://admin.piaoquantv.com/cms/post-detail/{i}/detail',
            'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
            'sec-ch-ua-mobile': '?0',
            'sec-ch-ua-platform': '"macOS"',
            'sec-fetch-dest': 'empty',
            'sec-fetch-mode': 'cors',
            'sec-fetch-site': 'same-origin',
            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
        }

        response = requests.request("GET", url, headers=headers, data=payload)
        data = response.json()
        try:
            code = data["code"]
            if code != 0:
                Common.logger().info(
                    f"未登录，请更换cookie，{data}")
                Feishu.bot('recommend', '管理后台', '管理后台cookie失效，请及时更换～')
                return ""
            audio_url = data["content"]["transedVideoPath"]
            print(audio_url)
            return audio_url
        except Exception as e:
            Common.logger().warning(f"获取音频视频链接失败:{e}\n")
            return ""

    @classmethod
    def video_stitching(cls):
        cookie = Material.get_houtai_cookie()
        # 获取音频类型+字幕
        audio_id, srt, title_list, type_audio = Material.get_audio_type()
        if type_audio == "口播--美文类":
            # 获取已入库的口播视频
            audio_list = cls.get_audio_list()
            videos = [list(item) for item in audio_list]
            videos = random.choice(videos) #随机选择视频
            # 判断该视频+音频是否生成过视频
            video = VideoStitching.get_audio_url_list(videos, audio_id)
            if video:
                Common.logger().info(f"该该视频+音频已经生成过视频，不做视频拼接")
                return
        else:
            # 获取已入库的用户id
            account_id = cls.get_account_id()
            account = random.choice(account_id)
            account = str(account).replace('(', '').replace(')', '').replace(',', '')
            Common.logger().info(f"获取用户ID：{account}")
            # 获取 未使用的视频链接
            url_list = cls.get_url_list(audio_id, account)
            videos = [list(item) for item in url_list]
        # 获取音频url
        audio = cls.get_audio_url(audio_id, cookie)
        if audio == "":
            Common.logger().info(f"获取音频地址为空")
            return
        Common.logger().info(f"获取音频地址：{audio},获取用户id：{audio_id}")

        # videos = Oss.get_oss_url(videos)
        # 视频截取
        try:
            audio_url, video_with_subtitles, clips = cls.concatenate_videos(videos, str(audio), srt, type_audio)
            if len(audio_url) == 0:
                Common.logger().info(f"视频生成失败")
            # 随机生成视频id
            id = cls.random_id()
            Common.logger().info(f"生成视频id为：{id}")
            # 上传 oss
            oss_object_key = Oss.stitching_sync_upload_oss(output_path, id)
            status = oss_object_key.get("status")
            # 获取 oss 视频地址
            oss_object_key = oss_object_key.get("oss_object_key")
            Common.logger().info(f"新拼接视频，oss发送成功，oss地址：{oss_object_key}")
            if status == 200:
                time.sleep(10)
                # 发送成功 已使用视频存入数据库
                if type_audio == "口播--美文类":
                    cls.insert_video_typeAudio(videos[0], audio_id)
                else:
                    cls.insert_videoAudio(audio_url, audio_id)
                Common.logger().info(f"发送成功 已使用视频存入数据库完成")
                if os.path.isfile(output_path):
                    os.remove(output_path)
                    Common.logger().info(f"文件删除成功{output_path}")
                else:
                    Common.logger().info(f"文件不存在{output_path}")
                piaoquantv = cls.insert_piaoquantv(oss_object_key, title_list)
                if piaoquantv:
                    Common.logger().info(f"视频添加到对应用户成功")
                    # 关闭视频文件
                    for clip in clips:
                        clip.close()
                    # 释放视频对象
                    video_with_subtitles.close()

        except Exception as e:
            Common.logger().warning(f"新拼接视频发送oss失败:{e}\n")
            return




if __name__ == '__main__':
    VideoStitching.video_stitching()