import re

class Process:
    def __init__(self, obj_websocket):
        self.obj_websocket = obj_websocket
        self.line_empty = 0

        # Data
        self.id = None
        self.fps: float = 0.0
        self.speed: float = 0.0

        self.quantizer: int = 0
        self.bitrate: list = [0, "kbits/s"]
        self.size: list = [0, "KiB"]

        self.time: int = 0
        self.frames: int = 0


    async def read_out(self, obj):
        self.id = obj.id

        while True:
            line = await obj.process.stderr.read(1024)
            line_decoded = line.decode()

            self.process_line_extract(obj, line_decoded)

            await self.obj_websocket.send_websocket(obj.to_dict())

            if self.line_empty > 20:
                break
            elif not line:
                self.line_empty += 1
            elif line:
                self.line_empty = 0

    def process_line_extract(self, obj, line:str):
        # FPS
        fps = re.findall(r"fps=\s*(\d+.\d*)", line)
        self.fps = float(fps[0]) if fps else 0
        obj.stat_fps = [obj.stats_fps[0] + self.fps, obj.stats_fps[1] + 1]

        # Quantizer
        q = re.findall(r"q=\s*(\d+).\d+", line)
        self.quantizer = int(q[0]) if q else 0
        obj.stat_quantizer = [obj.stat_quantizer[0] + self.quantizer, obj.stat_quantizer[1] + 1]

        # Bitrate
        bitrate = re.findall(r"bitrate=\s*(\d+)", line)
        self.bitrate[0] = int(bitrate[0]) if bitrate else 0
        obj.stat_bitrate = [obj.stat_bitrate[0] + self.bitrate, obj.stat_bitrate[1] + 1]

        # Speed
        speed = re.findall(r"speed=\s*(\d+\.\d+)", line)
        self.speed = float(speed[0]) if speed else 0
        obj.stat_speed = [obj.stat_speed[0] + self.speed, obj.stat_speed[1] + 1]

        # File Size
        size = re.findall(r"size=\s*(\d+)", line)
        if size and int(size[0]) > self.size[0]:
            self.size[0] = int(size[0])
            obj.process_size = self.size

        # Time
        media_time = re.findall(r"time=\s*(\d+:\d+:\d+)", line)
        time_v = media_time[0] if media_time else "00:00:00"
        if self.time < self.time_in_sec(time_v):
            self.time = self.time_in_sec(time_v)
            obj.process_time = self.time

        # Frames
        frame = re.findall(r"frame=\s*(\d+)", line)
        if frame and int(frame[0]) > self.frames:
            self.frames = int(frame[0])
            obj.process_frames = self.frames

    def to_dict(self):
        return {"data_flow": {self.id: {
            "frames": self.frames,
            "fps": self.fps,
            "quantizer": self.quantizer,
            "size": self.size,
            "time": self.time,
            "bitrate": self.bitrate,
            "speed": self.speed
        }}}

    # Data convert
    @staticmethod
    def time_in_sec(time_str: str) -> int:
        h, m, s = map(int, time_str.split(":"))
        return h * 3600 + m * 60 + s

    @staticmethod
    def size_convert(source: str, target, unit: str, size=0):
        list_unit: list = []

        if unit == "storage":
            list_unit = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]
        elif unit == "data_rate":
            list_unit = ["bps", "Kbps", "Mbps", "Gbps", "Tbps", "Pbps"]
        elif unit == "binary_data_rate":
            list_unit = ["b/s", "Kib/s", "Mib/s", "Gib/s", "Tib/s", "Pib/s"]

        factor = 1024  # Binäre Umrechnung

        if source not in list_unit:
            raise ValueError("Ungültige Quell-Einheit!")

        source_index = list_unit.index(source)

        if target:
            if target not in list_unit:
                raise ValueError("Ungültige Ziel-Einheit!")
            target_index = list_unit.index(target)

            if source_index < target_index:
                return size / (factor ** (target_index - source_index)), target
            else:
                return size * (factor ** (source_index - target_index)), target

        # Automatische Umrechnung
        while size >= 1000 and source_index < len(list_unit) - 1:
            size /= factor
            source_index += 1

        return [round(size,1), list_unit[source_index]]