from genericpath import exists
import os, sys
from asyncio_dvrip import DVRIPCam
import asyncio
from nvr_core import NVR
from nvr_types import File
import platform
import aiofiles

from global_funcs import *   

class Recorder:
    loop = asyncio.get_event_loop()
    def __init__(self, address, port, username, password, name = "", index = 0):
        self.address = address
        self.port = int(port)
        self.username = username
        self.password = password
        self.name = name
        self.index = index
        self.channels = 0

    @property
    def nvr(self):
        client = DVRIPCam(self.address, port = self.port, user = self.username, password = self.password)
        return NVR(client, self.loop)

    def __str__(self) -> str:
        if not self.name:
            return f"{self.address}:{self.port}"
        else:
            return self.name

class TranscodeStatus:
    def __init__(self, b64) -> None:
        self.b64 = b64
        self.uuid = str(uuid_from_string(b64))
        self.h264 = 0
        self.downloaded_h264_bytes = 0
        self.total_h264_bytes = 0
        self.avi = 0
        self.mp4 = 0
        self.outFile = None
        self.done = False
        self.outSize = 0
        self.error = ""

    @property
    def outName(self):
        if self.outFile:
            return os.path.split(self.outFile)[-1]
        return ""

    async def generate_bytes(self):
        async with aiofiles.open(self.outFile, "rb") as out:
            while True:
                chunk = await out.read(32 * 1024)
                if chunk:
                    yield chunk
                else:
                    break
            yield b""

class Go2RtcChannel:
    #vhod_hd: dvrip://bfwc:JQWwM146@192.168.5.2:34567?channel=3&subtype=0
    def __init__(self, recorder: Recorder, count_of_streams = 2) -> None:
        self.proto = "dvrip"
        self.login = recorder.username
        self.password = recorder.password
        self.host = f"{recorder.address}:{recorder.port}"
        self.recorder_index = recorder.index
        self.count_of_channels = recorder.channels
        self.count_of_streams = count_of_streams

    def generate_lines(self):
        lines = ""
        for i in range(0, self.count_of_channels):
            for j in range(0, self.count_of_streams):
                lines += f" {self.recorder_index}_{i}_{j}: {self.proto}://{self.login}:{self.password}@{self.host}?channel={i}&subtype={j}\n"
        return lines

class Go2Rtc:
    WIN = "https://github.com/AlexxIT/go2rtc/releases/download/v1.9.4/go2rtc_win64.zip"
    LNX = "https://github.com/AlexxIT/go2rtc/releases/download/v1.9.4/go2rtc_linux_amd64"

    def __init__(self) -> None:
        self.enabled = False
        try:
            self.check_exists()
        except:
            print("go2rtc is disabled")
            pass

    def check_exists(self):
        go2rtc_directory = os.path.join(app_dir(), "go2rtc")
        if os.path.exists(go2rtc_directory):
            print("Go2Rtc directory exists")
            if platform.system() == "Windows" and os.path.exists(os.path.join(go2rtc_directory, "go2rtc.exe")):
                print("[WIN] Go2Rtc is exists, continue create config")
                self.exec = os.path.join(go2rtc_directory, "go2rtc.exe")
                self.enabled = True
            elif platform.system() == "Linux" and os.path.exists(os.path.join(go2rtc_directory, "go2rtc")):
                print("[LNX] Go2Rtc is exists, continue create config")
                self.exec = os.path.join(go2rtc_directory, "go2rtc")
                self.enabled = True
            else:
                raise Exception(f"go2rtc not downloaded, windows: {self.WIN} linux: {self.LNX}")
        else:
            raise Exception("Go2Rtc not found, he is disabled")

    async def start_go2rtc(self, recorders):
        lines = "streams:\n"
        for recorder in recorders:
            lines += Go2RtcChannel(recorder, 2).generate_lines()
            
        cfg_file = os.path.join(app_dir(), "go2rtc", "go2rtc.yaml")
        print(f"go2rtc config: {cfg_file}")

        async with aiofiles.open(cfg_file, "w", encoding="utf8") as cfg:
            await cfg.write(lines)

        await asyncio.create_subprocess_exec(self.exec, *["-c", cfg_file])
        

class TranscodeTools:
    statuses:dict[str, TranscodeStatus] = {}
    WIN32PYTHON = "python-win32"

    def __init__(self, tools_directory, transcode_directory, hide_checks = True) -> None:
        self.hide_checks = hide_checks
        self.tools_directory = tools_directory
        self.transcode_directory = transcode_directory
        if not os.path.exists(tools_directory):
            print("download git repo https://git.pblr-nyk.pro/gsd/MiskaRisa264 and place in backend folder to enable transcode tools")
            self.enabled = False
        else:
            python_win32_exists = self.python_win32_exists
            if not python_win32_exists:
                print("download https://www.python.org/ftp/python/3.12.3/python-3.12.3-embed-win32.zip and unzip in backend/MiskaRisa/python-win32 all contains files")
            
            check_exists_needed_files = self.check_exists_needed_files
            if not check_exists_needed_files:
                print("MiskaRisa264 is not fully downloaded, watch in directory to find lost files")

            check_ffmpeg = self.check_ffmpeg()
            if not check_ffmpeg:
                print("ffmpeg in not installed on system or on windows in not in PATH env")

            check_converter = self.check_converter()
            if not check_converter:
                print("failed run h264_converter.py with python-win32")
            
            self.enabled = check_exists_needed_files and python_win32_exists and check_ffmpeg and check_converter
            if not self.enabled:
                print("Cannot enabled transcode tools, have a errors on init, run config_parser with --no-hide-check parameters to more info")

        print("Transcode tools", "enabled" if self.enabled else "disabled")

    @property
    def check_exists_needed_files(self):
        for file in ["H264Play.dll", "h264_converter.py", "StreamReader.dll"]:
            if not os.path.exists(os.path.join(self.tools_directory, file)):
                return False
        return True

    @property
    def python_win32_exists(self):
        return os.path.exists(os.path.join(self.tools_directory, self.WIN32PYTHON))

    @property
    def python_win32(self):
        return os.path.join(self.tools_directory, self.WIN32PYTHON, "python.exe")

    @property
    def converter_script(self):
        return os.path.join(self.tools_directory, "h264_converter.py")

    def check_ffmpeg(self):
        from subprocess import call, DEVNULL
        try:
            return not call("ffmpeg -version".split(), stdin=DEVNULL if self.hide_checks else None, stdout=DEVNULL if self.hide_checks else None, stderr=DEVNULL if self.hide_checks else None)
        except:
            return False

    def check_converter(self):
        from subprocess import call, DEVNULL
        cmd = f"{self.python_win32} {self.converter_script} --help"
        if platform.system() == "Linux":
            cmd = "wine " + cmd
        try:
            return not call(cmd.split(), stdin=DEVNULL if self.hide_checks else None, stdout=DEVNULL if self.hide_checks else None, stderr=DEVNULL if self.hide_checks else None)
        except:
            return False

    async def h264toavi(self, source_file, delete_source_file = False):
        exec_string = []
        exec_cmd = ""
        if platform.system() == "Windows":
            exec_cmd = f"{self.python_win32}"
        elif platform.system() == "Linux":
            exec_cmd = "wine"
            exec_string.append(self.python_win32)
        else:
            raise Exception("Unknown platform to transcode")

        exec_string.append(self.converter_script)
        exec_string.append(source_file)

        print("execute", exec_cmd, exec_string)
        proc = await asyncio.create_subprocess_exec(exec_cmd, *exec_string)
        await proc.communicate()

        if delete_source_file:
            os.remove(source_file)
        if os.path.exists(source_file + ".avi"):
            return source_file + ".avi"
        else:
            raise Exception("AVI not be created")

    async def avitomp4(self, source_file, delete_source_file = False):
        exec_string = ["-y", "-i", source_file, "-movflags", "faststart", f"{source_file}.mp4"]
        print("execute", exec_string)
        proc = await asyncio.create_subprocess_exec("ffmpeg", *exec_string)
        await proc.communicate()

        if delete_source_file:
            os.remove(source_file)
        if os.path.exists(source_file + ".mp4"):
            return source_file + ".mp4"
        else:
            raise Exception("MP4 not be created")

    def deleteFile(self, source_file):
        os.remove(source_file)

    async def processing_safe(self, status: TranscodeStatus, file:File, nvr: NVR, reCreate:bool = False):
        try:
            await self.processing(status, file, nvr, reCreate)
        except Exception as e:
            self.statuses[status.b64].error = str(e)

    async def processing(self, status: TranscodeStatus, file:File, nvr: NVR, reCreate:bool = False):
        raw_file = os.path.join(self.transcode_directory, status.uuid + ".h264")
        
        mp4_file = os.path.join(self.transcode_directory, status.uuid + ".h264.avi.mp4")
        if os.path.exists(mp4_file) and os.path.getsize(mp4_file) != 0:
            nvr.logout()
            self.statuses[status.b64].outFile = mp4_file
            self.statuses[status.b64].done = True
            self.statuses[status.b64].outSize = os.path.getsize(mp4_file)
            return

        if not os.path.exists(raw_file) or os.path.getsize(raw_file) != file.size:
            print("save raw file to", raw_file)
            async with aiofiles.open(raw_file, "wb") as raw:
                self.statuses[status.b64].total_h264_bytes = file.size
                async for chunk in nvr.stream_file(file):
                    self.statuses[status.b64].downloaded_h264_bytes += len(chunk)
                    self.statuses[status.b64].h264 = round(100 * self.statuses[status.b64].downloaded_h264_bytes / self.statuses[status.b64].total_h264_bytes)
                    await raw.write(chunk)
                print("raw file is downloaded")
        else:
            print("File already content on server")
        print("logout from nvr, he is not more needed")
        nvr.logout()

        self.statuses[status.b64].avi = 0
        avi_file = raw_file + ".avi"
        if not os.path.exists(avi_file) or reCreate:
            avi_file = await self.h264toavi(raw_file)
        else:
            print("file avi format already exitst")
        self.statuses[status.b64].avi = 100


        self.statuses[status.b64].mp4 = 0
        mp4_file = avi_file + ".mp4"
        if not os.path.exists(mp4_file) or reCreate:
            mp4_file = await self.avitomp4(avi_file)
        else:
            print("file mp4 format already exists")
        self.statuses[status.b64].mp4 = 100

        self.statuses[status.b64].outFile = mp4_file
        self.statuses[status.b64].done = True
        self.statuses[status.b64].outSize = os.path.getsize(mp4_file)

    async def transcode_test(self, raw_file):
        avi_file = await self.h264toavi(raw_file)
        mp4_file = await self.avitomp4(avi_file)

    def h264toavi_test(self, raw_file):
        loop = asyncio.get_event_loop()
        tasks = [loop.create_task(self.transcode_test(raw_file))]
        loop.run_until_complete(asyncio.wait(tasks))
        loop.close()

class Config:
    def __init__(self, config_name = "config.json", args = None) -> None:
        raw = load_config(config_name) if args == None or not args.err_check else {}
        self.listen_address = raw.get("backend", {}).get("address", "0.0.0.0")
        self.listen_port = int(raw.get("backend", {}).get("port", "8080"))
        self.recorders = []
        i = 0
        for raw_server in raw.get("recorders", []):
            self.recorders.append(Recorder(raw_server.get("ip"), raw_server.get("port"), raw_server.get("user"), raw_server.get("password"), raw_server.get("name", ""), index=i))
            i += 1
        if (self.recorders.__len__() == 0):
            print("Recorders not find")
        else:
            for recorder in self.recorders:
                print(recorder)
        self.transcode_tools:TranscodeTools = self.check_transcode_tools(not args.no_hide_check if args != None else True)

    def getRecorder(self, index = 0) -> Recorder:
        return self.recorders[index]

    def getRecorders(self):
        return [str(r) for r in self.recorders]

    def check_transcode_directory(self):
        t_dir = os.path.join(app_dir(), "transcode")
        if not os.path.exists(t_dir):
            os.mkdir(t_dir)
        return t_dir

    def check_transcode_tools(self, hide_check):
        tools_dir = os.path.join(app_dir(), "MiskaRisa264")
        return TranscodeTools(tools_dir, self.check_transcode_directory(), hide_check)

if __name__ == "__main__":
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("--no-hide-check", action="store_true")
    parser.add_argument("--err-check", action="store_true")
    parser.add_argument("--test-h264toavi", type=str)
    args = parser.parse_args()
    config = Config(args = args)
    if args.err_check:
        sys.exit(0 if config.transcode_tools.enabled else 1)

    if args.test_h264toavi:
        config.transcode_tools.h264toavi_test(args.test_h264toavi)
        sys.exit(0)

    sys.exit(0)