from pkg import sunshine
from pkg.sunshine.structs import SunshineEnvironmentVariables

from pkg import wayland_display_manager
from pkg.wayland_display_manager.structs import Modeline

from app.vars import Arguments, Instructions, CONFIG_DIR,  GEN_SCRIPT_PATH, PREVIOUS_MODE_PATH
from app.errors import Errors

import sys
import os
import stat

def calculate_closest_mode(sunshine_env: SunshineEnvironmentVariables, supported_modes: list[Modeline]) -> Modeline:
    def _distance(mode: Modeline):
        return(
            abs(mode.width - sunshine_env.specs.width) *2 +
            abs(mode.height - sunshine_env.specs.height) *2 +
            abs(mode.refresh_rate - sunshine_env.specs.fps)
        )
    
    return min(supported_modes, key = _distance)

def main():
    try:
        os.mkdir(CONFIG_DIR)
    except FileExistsError:
        pass

    sunshine_env = sunshine.load_env_variables()
    display_manager = wayland_display_manager.get_display()

    if len(sys.argv) -1 < Arguments.CONNECTOR:
        raise SyntaxError(Errors.INSUFFICIENT_INSTRUCTIONS)
    
    match sys.argv[Arguments.INSTRUCTION]:
        case Instructions.SET:
            display_manager.save_current_mode(PREVIOUS_MODE_PATH)

            for i in display_manager.get_modes():
                if i.connector == sys.argv[Arguments.CONNECTOR]:
                    display_modes = i.modes

            if display_modes:
                modeline = calculate_closest_mode(sunshine_env, display_modes)

                display_manager.set_mode(
                    modeline = modeline,
                    requested_connector = sys.argv[Arguments.CONNECTOR]
                )
            else:
                raise ValueError(Errors.CONNECTOR_INVALID)
            
        case Instructions.RESET:
            modeline = display_manager.read_saved_mode(PREVIOUS_MODE_PATH)

            display_manager.set_mode(modeline, sys.argv[Arguments.CONNECTOR])

        case Instructions.CREATE:
            if len(sys.argv) -1 < Arguments.TEMPLATE:
                raise SyntaxError(Errors.INSUFFICIENT_INSTRUCTIONS)
    
            for i in display_manager.get_modes():
                if i.connector == sys.argv[Arguments.CONNECTOR]:
                    display_modes = i.modes

            modeline = calculate_closest_mode(sunshine_env, display_modes)

            with open(GEN_SCRIPT_PATH, "w") as file:
                file.write("#!/bin/bash\n" + sys.argv[Arguments.TEMPLATE].format(
                    res_x = modeline.width,
                    res_y = modeline.height,
                    rate = modeline.refresh_rate
                ))

            os.chmod(
                GEN_SCRIPT_PATH,
                stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR |
                stat.S_IRGRP | stat.S_IXGRP |
                stat.S_IROTH | stat.S_IXOTH
            )

        case _:
            raise ValueError(Errors.CONNECTOR_UNSPECIFIED)

if __name__ == "__main__":
    main()