import subprocess
from pathlib import Path
import sys
import os
import logging
from datetime import datetime
from time import time
from rich.logging import RichHandler
from rich.progress import Progress
from pickle import dumps, loads
from typing import Optional
import atexit
import re
import threading
import queue
import psutil
from concurrent.futures import ThreadPoolExecutor, as_completed

root = None
TRAIN = False
ESTI_FILE = Path(sys.path[0])/"esti.out"
CFG_FILE = Path(sys.path[0])/"config.json"
CFG = {
    "save_to": "single",
    "crf":"18",
    "bitrate": None,
    "codec": "h264",
    "extra": [],
    "ffmpeg": "ffmpeg",
    "manual": None,
    "video_ext": [".mp4", ".mkv"],
    "train": False,
    "compress_dir_name": "compress",
    "resolution": "-1:1080",
    "fps": "30",
    "esti_data_file": "estiminate_data.dat",
    "test_video_resolution": "1920x1080",
    "test_video_fps": "30",
    "test_video_input": "compress_video_test.mp4",
    "test_video_output": "compressed_video_test.mp4",
    "max_concurrent_instances": 2,
    "cpu_monitor_interval": 3,  # CPU监控间隔（秒）
    "cpu_monitor_duration": 30,  # 统计持续时间（秒，5分钟）
}
esti=None # :tuple[list[int],list[float]]

# CPU监控相关全局变量
ffmpeg_processes = {}  # 存储活动的ffmpeg进程
cpu_stats = {"system": [], "ffmpeg": []}  # CPU使用率统计
cpu_monitor_thread = None
cpu_monitor_lock = threading.Lock()
current_instances = 0
instance_lock = threading.Lock()

def get_cmd(video_path,output_file):
    if CFG["manual"] is not None:
        command=[
            CFG["ffmpeg"],  
            "-hide_banner", 
            "-i", video_path
        ]
        command.extend(CFG["manual"])
        command.append(output_file)
        return command
    
    if CFG["bitrate"] is not None:
        command = [
            CFG["ffmpeg"],  
            "-hide_banner",
            "-i", video_path,
        ]
        if CFG['resolution'] is not None:
            command.extend([
            "-vf", f"scale={CFG['resolution']}",])
        command.extend([
            "-c:v", CFG["codec"],
            "-b:v", CFG["bitrate"],
            "-r",CFG["fps"],
            "-y",
        ])
    else:
        command = [
            CFG["ffmpeg"],  
            "-hide_banner",
            "-i", video_path,
            ]
        if CFG['resolution'] is not None:
            command.extend([
            "-vf", f"scale={CFG['resolution']}",])
        command.extend([
            "-c:v", CFG["codec"],
            "-global_quality", str(CFG["crf"]),
            "-r",CFG["fps"],
            "-y",
        ])
    
    command.extend(CFG["extra"])
    command.append(output_file)
    return command

def train_init():
    global esti_data,TRAIN,data_file
    data_file = Path(CFG["esti_data_file"])
    if data_file.exists():
        esti_data=loads(data_file.read_bytes())
        if not isinstance(esti_data,tuple):
            esti_data=([],[])
    else:
        esti_data=([],[])
    TRAIN=True
    atexit.register(save_esti)
    # print(esti_data)


# 配置logging
def setup_logging():
    log_dir = Path("logs")
    log_dir.mkdir(exist_ok=True)
    log_file = log_dir / f"video_compress_{datetime.now().strftime('%Y%m%d')}.log"
    stream = RichHandler(rich_tracebacks=True,tracebacks_show_locals=True)
    stream.setLevel(logging.INFO)
    stream.setFormatter(logging.Formatter("%(message)s"))
    
    file = logging.FileHandler(log_file, encoding='utf-8')
    file.setLevel(logging.DEBUG)
    
    logging.basicConfig(
        level=logging.DEBUG,
        format='%(asctime)s - %(levelname) 7s - %(message)s',
        handlers=[
            file,
            stream
        ]
    )

def polyfit_manual(x, y, degree=2):
    """手动实现二次多项式最小二乘拟合"""
    n = len(x)
    if n != len(y):
        raise ValueError("输入的x和y长度必须相同")
    
    # 对于二次多项式 y = ax^2 + bx + c
    # 构建矩阵方程 A * [a, b, c]^T = B
    # 其中 A = [[sum(x^4), sum(x^3), sum(x^2)], 
    #          [sum(x^3), sum(x^2), sum(x)], 
    #          [sum(x^2), sum(x), n]]
    # B = [sum(x^2 * y), sum(x * y), sum(y)]
    
    # 计算需要的和
    sum_x = sum(x)
    sum_x2 = sum(xi**2 for xi in x)
    sum_x3 = sum(xi**3 for xi in x)
    sum_x4 = sum(xi**4 for xi in x)
    sum_y = sum(y)
    sum_xy = sum(xi*yi for xi, yi in zip(x, y))
    sum_x2y = sum(xi**2*yi for xi, yi in zip(x, y))
    
    # 构建矩阵A和向量B
    A = [
        [sum_x4, sum_x3, sum_x2],
        [sum_x3, sum_x2, sum_x],
        [sum_x2, sum_x, n]
    ]
    B = [sum_x2y, sum_xy, sum_y]
    
    # 使用高斯消元法解线性方程组
    # 将增广矩阵 [A|B] 转换为行阶梯形式
    AB = [row + [b] for row, b in zip(A, B)]
    n_rows = len(AB)
    
    # 高斯消元
    for i in range(n_rows):
        # 寻找当前列中最大元素所在的行
        max_row = i
        for j in range(i + 1, n_rows):
            if abs(AB[j][i]) > abs(AB[max_row][i]):
                max_row = j
        
        # 交换行
        AB[i], AB[max_row] = AB[max_row], AB[i]
        
        # 将当前行主元归一化
        pivot = AB[i][i]
        if pivot == 0:
            raise ValueError("矩阵奇异，无法求解")
        
        for j in range(i, n_rows + 1):
            AB[i][j] /= pivot
        
        # 消元
        for j in range(n_rows):
            if j != i:
                factor = AB[j][i]
                for k in range(i, n_rows + 1):
                    AB[j][k] -= factor * AB[i][k]
    
    # 提取结果
    coeffs = [AB[i][n_rows] for i in range(n_rows)]
    
    return coeffs  # [a, b, c] 对应 ax^2 + bx + c

def save_esti():
    try:
        if len(esti_data[0]) > 0:
            coeffs = polyfit_manual(esti_data[0], esti_data[1])
            # 保存为逗号分隔的文本格式
            ESTI_FILE.write_text(','.join(map(str, coeffs)))
    except Exception as e:
        logging.warning("保存估算数据失败")
        logging.debug("error at save_esti",exc_info=e)

def fmt_time(t:float|int) -> str:
    if t>3600:
        return f"{t//3600}h {t//60}min {t%60}s"
    elif t>60:
        return f"{t//60}min {t%60}s"
    else:
        return f"{round(t)}s"

def cpu_monitor():
    """CPU监控线程函数"""
    global cpu_stats
    
    while True:
        try:
            # 获取系统CPU使用率
            system_cpu = psutil.cpu_percent(interval=1)
            
            # 获取所有ffmpeg进程的CPU使用率
            ffmpeg_cpu_total = 0
            active_processes = []
            
            with cpu_monitor_lock:
                for proc_info in ffmpeg_processes.values():
                    try:
                        proc = proc_info['process']
                        if proc.is_running():
                            # print(proc,proc.cpu_percent() / psutil.cpu_count())
                            ffmpeg_cpu_total += proc.cpu_percent() / psutil.cpu_count()
                            active_processes.append(proc_info)
                    except (psutil.NoSuchProcess, psutil.AccessDenied):
                        continue
            
            # 更新统计数据
            with cpu_monitor_lock:
                cpu_stats["system"].append(system_cpu)
                cpu_stats["ffmpeg"].append(ffmpeg_cpu_total)
                
                # 保持最近5分钟的数据
                max_samples = CFG["cpu_monitor_duration"] // CFG["cpu_monitor_interval"]
                if len(cpu_stats["system"]) > max_samples:
                    cpu_stats["system"] = cpu_stats["system"][-max_samples:]
                if len(cpu_stats["ffmpeg"]) > max_samples:
                    cpu_stats["ffmpeg"] = cpu_stats["ffmpeg"][-max_samples:]
            
            logging.debug(f"CPU监控: 系统={system_cpu:.1f}%, FFmpeg总计={ffmpeg_cpu_total:.1f}%, 活动进程={len(active_processes)}")
        except KeyboardInterrupt as e:
            raise e
        except Exception as e:
            logging.debug(f"CPU监控异常: {e}")
        
        # 等待下一次监控
        threading.Event().wait(CFG["cpu_monitor_interval"])

def start_cpu_monitor():
    """启动CPU监控线程"""
    global cpu_monitor_thread
    if cpu_monitor_thread is None or not cpu_monitor_thread.is_alive():
        cpu_monitor_thread = threading.Thread(target=cpu_monitor, daemon=True)
        cpu_monitor_thread.start()
        logging.info("CPU监控线程已启动")

def get_cpu_usage_stats():
    """获取CPU使用率统计"""
    with cpu_monitor_lock:
        if not cpu_stats["system"] or not cpu_stats["ffmpeg"]:
            return None, None
        
        system_avg = sum(cpu_stats["system"]) / len(cpu_stats["system"])
        ffmpeg_avg = sum(cpu_stats["ffmpeg"]) / len(cpu_stats["ffmpeg"])
        
    return system_avg, ffmpeg_avg

def should_increase_instances():
    """判断是否应该增加实例数"""
    system_avg, ffmpeg_avg = get_cpu_usage_stats()
    
    if system_avg is None or ffmpeg_avg is None:
        return False
    
    # 条件: 系统CPU - FFmpeg CPU > FFmpeg CPU * 2 + 0.1
    available_cpu = 100 - system_avg
    threshold = ffmpeg_avg  # 10% = 0.1 * 100
    
    logging.debug(f"CPU统计: 系统平均={system_avg:.1f}%, FFmpeg平均={ffmpeg_avg:.1f}%, 可用={available_cpu:.1f}%, 阈值={threshold:.1f}%")
    
    return available_cpu > threshold

def register_ffmpeg_process(proc_id, process):
    """注册ffmpeg进程用于监控"""
    with cpu_monitor_lock:
        ffmpeg_processes[proc_id] = {
            'process': psutil.Process(process.pid),
            'start_time': time()
        }

def unregister_ffmpeg_process(proc_id):
    """注销ffmpeg进程"""
    with cpu_monitor_lock:
        if proc_id in ffmpeg_processes:
            del ffmpeg_processes[proc_id]

def func(sz:int,src=False):
    if TRAIN:
        try:
            data_file.write_bytes(dumps(esti_data))
        except KeyboardInterrupt as e:raise e
        except Exception as e:
            logging.warning("无法保存数据",exc_info=e)
    try:
        if TRAIN:
            if len(esti_data[0])==0:
                return -1 if src else "NaN"
            coeffs = polyfit_manual(esti_data[0], esti_data[1])
            t = coeffs[0]*sz**2 + coeffs[1]*sz + coeffs[2]
        elif esti is not None:
            t = esti[0]*sz**2 + esti[1]*sz + esti[2]
            # print(t,sz)
        else:
            logging.warning(f"Unexpected condition at func->TRAIN")
            return -1 if src else "NaN"
        t = round(t)
        if src:
            return t
        return fmt_time(t)
    except KeyboardInterrupt as e:raise e
    except Exception as e:
        logging.warning("无法计算预计时间")
        logging.debug("esti time exception", exc_info=e)
        return -1 if src else "NaN"
    
def process_video(video_path: Path, compress_dir:Optional[Path]=None, update_func=None, proc_id=None):
    global esti_data, current_instances
    use=None
    sz=video_path.stat().st_size//(1024*1024)
    
    bgn=time()
    if compress_dir is None:
        # 在视频文件所在目录下创建 compress 子目录（如果不存在）
        compress_dir = video_path.parent / CFG["compress_dir_name"]
    else:
        compress_dir /= video_path.parent.relative_to(root)
        
    compress_dir.mkdir(exist_ok=True,parents=True)
    
    # 输出文件路径：与原文件同名，保存在 compress 目录下
    output_file = compress_dir / (video_path.stem + video_path.suffix)
    if output_file.is_file():
        logging.warning(f"文件{output_file}存在，跳过")
        return use
    
    video_path_str = str(video_path.absolute())
    command = get_cmd(video_path_str,output_file)
    
    try:
        with instance_lock:
            current_instances += 1
        
        logging.debug(f"启动FFmpeg进程 {proc_id}: {video_path.name}")
        
        result = subprocess.Popen(
            command, 
            stdout=subprocess.PIPE, 
            stderr=subprocess.PIPE,
            encoding="utf-8", 
            text=True
        )
        
        # 注册进程用于CPU监控
        if proc_id:
            register_ffmpeg_process(proc_id, result)
        
        while result.poll() is None:
            line = " "
            while result.poll() is None and line[-1:] not in "\r\n":
                line+=result.stderr.read(1)
            if 'warning' in line.lower():
                logging.warning(f"[FFmpeg {proc_id}]({video_path_str}): {line}")
            elif 'error' in line.lower():
                logging.error(f"[FFmpeg {proc_id}]({video_path_str}): {line}")
            elif "frame=" in line:
                match = re.search(r"frame=\s*(\d+)",line)
                if match:
                    frame_number = int(match.group(1))
                    if update_func is not None:
                        update_func(frame_number)

        if result.returncode != 0:
            logging.error(f"处理文件 {video_path_str} 失败，返回码: {result.returncode}，cmd={' '.join(map(str,command))}")
            logging.error(result.stdout.read())
            logging.error(result.stderr.read())
        else:
            logging.debug(f"文件处理成功: {video_path_str} -> {output_file}")
            
            end=time()
            if TRAIN:
                esti_data[0].append(sz)
                esti_data[1].append(end-bgn)
    except KeyboardInterrupt as e:raise e
    except Exception as e:
        logging.error(f"执行 ffmpeg 命令时发生异常, 文件：{str(video_path_str)}，cmd={' '.join(map(str,command))}",exc_info=e)
    finally:
        # 注销进程监控
        if proc_id:
            unregister_ffmpeg_process(proc_id)
        
        with instance_lock:
            current_instances -= 1
            
        logging.debug(f"FFmpeg进程 {proc_id} 已结束")
        
    return use

def traverse_directory(root_dir: Path):
    global current_instances
    video_extensions = set(CFG["video_ext"])
    sm=None
    if esti is not None:
        raise DeprecationWarning("不再支持训练模式")
        logging.info(f"正在估算时间（当存在大量小文件时，估算值将会很离谱）")
        sm = 0
        for file in root_dir.rglob("*"):
            if file.parent.name.lower() == CFG["compress_dir_name"].lower():continue
            if file.is_file() and file.suffix.lower() in video_extensions:
                sz=file.stat().st_size//(1024*1024)
                tmp = func(sz,True)
                if not isinstance(tmp,int):
                    logging.error("无法预估时间，因为预估函数返回非整数")
                elif tmp == -1:
                    logging.error("无法预估时间，因为预估函数返回了异常")
                sm += tmp
        logging.info(f"预估用时：{fmt_time(sm)}")
    else:
        # 获取视频文件列表和帧数信息
        video_files = []
        que = list(root_dir.glob("*"))
        while que:
            d = que.pop()
            for file in d.glob("*"):
                if file.parent.name == CFG["compress_dir_name"] or file.name == CFG["compress_dir_name"]:
                    continue
                if file.is_file() and file.suffix.lower() in video_extensions:
                    video_files.append(file)
                elif file.is_dir():
                    que.append(file)
                
            
        # exit()
        
        if not video_files:
            logging.warning("未找到需要处理的视频文件")
            return
            
        # 获取视频信息
        with Progress() as prog:
            task = prog.add_task("正在获取视频信息", total=len(video_files))
            frames: dict[Path, float] = {}
            for file in video_files:
                prog.advance(task)
                cmd = f'ffprobe -v error -select_streams v:0 -show_entries stream=avg_frame_rate,duration -of default=nokey=1:noprint_wrappers=1'.split()
                cmd.append(str(file))
                proc = subprocess.run(cmd, shell=True, capture_output=True, text=True)
                if proc.returncode != 0:
                    logging.debug(f"无法获取视频信息: {file}, 返回码: {proc.returncode}")
                    frames[file] = 0
                    continue
                if proc.stdout.strip():
                    try:
                        avg_frame_rate, duration = proc.stdout.strip().split('\n')
                        tmp = avg_frame_rate.split('/')
                        avg_frame_rate = float(tmp[0]) / float(tmp[1])
                        if duration == "N/A":
                            duration = 0
                            logging.debug(f"无法获取视频信息: {file}, 时长为N/A，默认使用0s")
                        duration = float(duration)
                        frames[file] = duration * avg_frame_rate
                    except (ValueError, IndexError) as e:
                        logging.debug(f"解析视频信息失败: {file}, 错误: {e}")
                        frames[file] = 0
    
    logging.debug(f"开始遍历目录: {root_dir}, 共{len(frames)}个视频文件")
    
    # 启动CPU监控
    start_cpu_monitor()
    
    # 创建进度条
    with Progress() as prog:
        total_frames = sum(frames.values())
        main_task = prog.add_task("总进度", total=total_frames if total_frames > 0 else len(frames))
        
        # 创建文件队列
        file_queue = queue.Queue()
        for file in frames.keys():
            file_queue.put(file)
        
        # 进度跟踪
        progress_trackers = {}
        completed_files = 0
        total_completed_frames = 0
        
        def create_progress_updater(file_path, task_id):
            def update_progress(frame_count):
                nonlocal total_completed_frames
                if file_path in progress_trackers:
                    old_frames = progress_trackers[file_path]
                    diff = frame_count - old_frames
                    total_completed_frames += diff
                else:
                    total_completed_frames += frame_count
                progress_trackers[file_path] = frame_count
                
                if frames[file_path] > 0:
                    prog.update(task_id, completed=frame_count)
                else:
                    prog.update(task_id, description=f"{file_path.relative_to(root_dir)} 已处理{frame_count}帧")
                
                # 更新总进度
                if total_frames > 0:
                    prog.update(main_task, completed=total_completed_frames)
            return update_progress
        
        def process_file_worker():
            nonlocal completed_files
            while True:
                try:
                    file = file_queue.get(timeout=1)
                except queue.Empty:
                    break
                
                filename = file.relative_to(root_dir)
                
                # 创建文件级进度条
                if frames[file] == 0:
                    file_task = prog.add_task(f"{filename}")
                else:
                    file_task = prog.add_task(f"{filename}", total=frames[file])
                
                progress_updater = create_progress_updater(file, file_task)
                
                # 处理视频
                proc_id = f"worker_{threading.current_thread().ident}_{completed_files}"
                
                if CFG["save_to"] == "single":
                    process_video(file, root_dir/"Compress", progress_updater, proc_id)
                else:
                    process_video(file, None, progress_updater, proc_id)
                
                # 更新完成计数
                with instance_lock:
                    completed_files += 1
                    if total_frames == 0:  # 如果没有总帧数，按文件数计算
                        prog.update(main_task, completed=completed_files)
                
                # 移除文件级进度条
                prog.remove_task(file_task)
                file_queue.task_done()
        
        # 动态管理线程数
        active_threads = []
        max_workers = CFG["max_concurrent_instances"]
        
        def manage_workers():
            nonlocal active_threads
            
            while completed_files < len(frames) or any(t.is_alive() for t in active_threads):
                # 清理已完成的线程
                active_threads = [t for t in active_threads if t.is_alive()]
                
                # 检查是否需要增加实例
                current_worker_count = len(active_threads)
                
                if current_worker_count < max_workers and not file_queue.empty():
                    # 检查CPU使用率（运行5分钟后开始检查）
                    should_add_worker = False
                    if len(cpu_stats["system"]) >= 10:  # 至少有5分钟的数据
                        if current_worker_count >= 1:  # 已有实例运行
                            should_add_worker = should_increase_instances()
                            if should_add_worker:
                                logging.info("CPU资源充足，启动第二个压缩实例")
                            else:
                                should_add_worker = False
                    
                    if should_add_worker:
                        worker_thread = threading.Thread(target=process_file_worker, daemon=True)
                        worker_thread.start()
                        active_threads.append(worker_thread)
                        logging.debug(f"启动新的工作线程，当前活动线程数: {len(active_threads)}")
                
                threading.Event().wait(5)  # 每5秒检查一次
            
            # 等待所有线程完成
            for thread in active_threads:
                thread.join()
        
        # 启动第一个工作线程
        if not file_queue.empty():
            first_worker = threading.Thread(target=process_file_worker, daemon=True)
            first_worker.start()
            active_threads.append(first_worker)
            logging.info("启动第一个压缩实例")
            
            # 启动线程管理器
            manager_thread = threading.Thread(target=manage_workers, daemon=True)
            manager_thread.start()
            
            # 等待管理线程完成
            manager_thread.join()
    
    logging.info(f"所有视频处理完成，共处理了 {completed_files} 个文件")

def test():
    os.environ["PATH"] = Path(__file__).parent.as_posix() + os.pathsep + os.environ["PATH"]

    try:
        subprocess.run([CFG["ffmpeg"],"-version"],stdout=-3,stderr=-3).check_returncode()
    except KeyboardInterrupt as e:raise e
    except Exception as e:
        print(__file__)
        logging.critical("无法运行ffmpeg")
        exit(-1)
    try:
        ret = subprocess.run(
            f"ffmpeg -hide_banner -f lavfi -i testsrc=duration=1:size={CFG['test_video_resolution']}:rate={CFG['test_video_fps']} -c:v libx264 -y -pix_fmt yuv420p {CFG['test_video_input']}".split(),
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        if ret.returncode != 0:
            logging.warning("无法生成测试视频.")
            logging.debug(ret.stdout)
            logging.debug(ret.stderr)
            ret.check_returncode()
        cmd = get_cmd(CFG["test_video_input"],CFG["test_video_output"],)
        ret = subprocess.run(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        if ret.returncode != 0:
            logging.error("测试视频压缩失败")
            logging.debug(ret.stdout)
            logging.debug(ret.stderr)
            logging.error("Error termination via test failed.")
            exit(-1)
        os.remove("compress_video_test.mp4")
        os.remove("compressed_video_test.mp4")
    except KeyboardInterrupt as e:raise e
    except Exception as e:
        if os.path.exists("compress_video_test.mp4"):
            os.remove("compress_video_test.mp4")
        logging.warning("测试未通过，继续运行可能出现未定义行为。")
        logging.debug("Test error",exc_info=e)

def init_train():
    global esti
    if CFG["train"]:
        train_init()
    else:
        if ESTI_FILE.exists():
            try:
                # 从文件读取系数
                coeffs_str = ESTI_FILE.read_text().strip().split(',')
                esti = [float(coeff) for coeff in coeffs_str]
            except KeyboardInterrupt as e:raise e
            except Exception as e:
                logging.warning(f"预测输出文件{str(ESTI_FILE)}存在但无法读取", exc_info=e)

def exit_pause():
    if os.name == 'nt':
        os.system("pause")
    elif os.name == 'posix':
        os.system("read -p 'Press Enter to continue...'")

def main(_root = None):
    
    atexit.register(exit_pause)
    
    global root, esti
    setup_logging()
    tot_bgn = time()
    logging.info("-------------------------------")
    logging.info(datetime.now().strftime('Video Compress started at %Y/%m/%d %H:%M'))
    
    if CFG_FILE.exists():
        try:
            import json
            cfg:dict = json.loads(CFG_FILE.read_text())
            CFG.update(cfg)
        except KeyboardInterrupt as e:raise e
        except Exception as e:
            logging.warning("Invalid config file, ignored.")
            logging.debug(e)
    
    if _root is not None:
        root = Path(_root)
    else:
        # 通过命令行参数传入需要遍历的目录
        if len(sys.argv) < 2:
            print(f"用法：python {__file__} <目标目录>")
            logging.warning("Error termination via invalid input.")
            sys.exit(1)
        root = Path(sys.argv[1])
    
    if root.name.lower() == CFG["compress_dir_name"].lower():
        logging.critical("请修改目标目录名为非compress。")
        logging.error("Error termination via invalid input.")
        sys.exit(1) 

    logging.info("开始验证环境")
    test()
    
    init_train()
    
    if not root.is_dir():
        print("提供的路径不是一个有效目录。")
        logging.warning("Error termination via invalid input.")
        sys.exit(1)
    
    try:
        traverse_directory(root)
        tot_end = time()
        logging.info(f"Elapsed time: {fmt_time(tot_end-tot_bgn)}")
        logging.info("Normal termination of Video Compress.")
    except KeyboardInterrupt:
        logging.warning("Error termination via keyboard interrupt, CHECK IF LAST PROCSSING VIDEO IS COMPLETED.")
    except Exception as e:
        logging.error("Error termination via unhandled error, CHECK IF LAST PROCSSING VIDEO IS COMPLETED.",exc_info=e)

if __name__ == "__main__":
    main()