import os
import re
from datetime import datetime


class Video:
    def __init__(self, path):
        self.id = id(self)
        self.source_file = path
        self.output_file = f"{path.rsplit(".", 1)[0]}.webm"
        self.frame = 0
        self.fps = 0
        self.q = 0
        self.size = 0
        self.time = 0
        self.bitrate = 0
        self.speed = 0
        self.finished = 0
        self.progress = None
        self.duration = 0
        self.loading = 0
        self.error = []

    def to_dict(self):
        self.calc_loading()

        return {
            "source": os.path.basename(self.source_file),
            "target": os.path.basename(self.output_file),
            "path": os.path.dirname(self.source_file),
            "id": self.id,
            "frame": self.frame,
            "fps": self.fps,
            "q": self.q,
            "size": self.size,
            "time": self.time,
            "bitrate": self.bitrate,
            "speed": self.speed,
            "finished": self.finished,
            "duration": self.duration,
            "loading": self.loading
        }

    def extract_convert_data(self, line_decoded):
        frame = re.findall(r"frame=\s*(\d+)", line_decoded)
        self.frame = frame[0] if frame else 0

        fps = re.findall(r"fps=\s*(\d+.\d+)", line_decoded)
        self.fps = fps[0] if fps else 0

        q = re.findall(r"q=\s*(\d+.\d+)", line_decoded)
        self.q = q[0] if q else 0

        size = re.findall(r"size=\s*(\d+)", line_decoded)
        self.size = self.convert_kb_mb(size[0]) if size else 0

        time = re.findall(r"time=\s*(\d+:\d+:\d+)", line_decoded)
        time_v = time[0] if time else "00:00:00"
        self.time = self.time_in_sec(time_v)

        bitrate = re.findall(r"bitrate=\s*(\d+)", line_decoded)
        self.bitrate = self.convert_kb_mb(bitrate[0]) if bitrate else 0

        speed = re.findall(r"speed=\s*(\d+\.\d+)", line_decoded)
        self.speed = speed[0] if speed else 0

    @staticmethod
    def time_in_sec(time_str):
        hs_ms_s = re.findall(r"\s*(\d+):(\d+):(\d+)", time_str)
        if len(hs_ms_s[0]) >= 3:
            if hs_ms_s[0][0].isdigit() and hs_ms_s[0][1].isdigit() and hs_ms_s[0][2].isdigit():
                try:
                    return int(hs_ms_s[0][0]) * 3600 + int(hs_ms_s[0][1]) * 3600 + int(hs_ms_s[0][2])
                except ValueError:
                    return 0

    def calc_loading(self):
        if self.duration.is_integer():
            self.loading = round(self.time / self.duration * 100)
        else:
            self.loading = 0

    @staticmethod
    def convert_kb_mb(digits):
        if digits.isdigit():
            return round(int(digits) / 1024, 2)
        else:
            return 0