import logging
import re
import asyncio

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.time_remaining = 0
        self.loading = 0
        self.frames: int = 0


    async def read_out(self, obj):
        self.id = obj.id
        self.line_empty = 0
        i = 100

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

            self.process_line_extract(obj, line_decoded)
            #logging.info(line_decoded)

            self.loading = (self.frames / obj.source_frames_total) * 100

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

            if self.line_empty > 30:
                break
            elif not line:
                self.line_empty += 1
                await asyncio.sleep(2)
                continue
            elif line:
                self.line_empty = 0

            if i == 100 or i == 200 or i == 300 or i == 400 or i == 500:
                logging.info(self.to_dict(obj))
                self.save_stat_value(obj)
            elif i == 101 or i == 501:
                i = 0
                time = self.time_remaining
                if time != "  ":
                    logging.info(f"Time remaining: {time}")

            i += 1

    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.0

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

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

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

        # File Size
        size = re.findall(r"size=\s*(\d+)", line)
        if size and int(size[0]) > self.size[0]:
            self.size = obj.size_convert("KiB", None, "storage", 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 < obj.time_in_sec(time_v):
            self.time = obj.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 save_stat_value(self, obj):
        if self.fps:
            obj.stat_fps = [obj.stat_fps[0] + self.fps, obj.stat_fps[1] + 1]

        if self.quantizer:
            obj.stat_quantizer = [obj.stat_quantizer[0] + self.quantizer, obj.stat_quantizer[1] + 1]

        if self.bitrate[0]:
            obj.stat_bitrate = [obj.stat_bitrate[0] + self.bitrate[0], obj.stat_bitrate[1] + 1]

        if self.speed:
            obj.stat_speed = [obj.stat_speed[0] + self.speed, obj.stat_speed[1] + 1]

    def to_dict(self, obj):
        return {"data_flow": {
            "id": self.id,
            "frames": self.frames,
            "fps": self.fps,
            "quantizer": self.quantizer,
            "size": self.size,
            "time": obj.format_time(self.time, "Tage", "Std", "Min", None),
            "time_remaining": obj.format_time(obj.time_remaining(), None, "Std", "Min", None),
            "loading": self.loading,
            "bitrate": self.bitrate,
            "speed": self.speed
        }}