from libs.fspn.utils.wrapper_util import *
from libs.fspn.utils.observable import Observable, Event
from libs.fspn.protocol.server import Server
from libs.fspn.protocol.connection import Connection, EVENTS as CONNECTION_EVENTS, STATUS as CONNECTION_STATUS
from libs.fspn.protocol.security import Security, Pmc
from libs.app.updater import Updater

# from libs.api.api import Api
# from .zechoSocketio import HandlerSocketio

import pathlib
from enum import Enum, auto
import importlib
import logging, traceback
import json
import random, time
import secrets
import os
import sys

from libs.app.common.logging import get_logger, get_logger_buffer
from libs.app.common.paths import ROOT_DIR
from .peers import PeerManager
from .users import UserManager
from .modules import ModuleManager
from libs.app.common.config import Config
from .events import Events
from .connections import ConnectionManager
from .dispatcher import Dispatcher
from .servers import ServerManager
from .dataManager import DataManager
from .networks import Networks

logger = get_logger(buffer=True)

class NoSysCore(Observable):
    def __init__(self):
        super().__init__()

    def start(self):
        logger.info(f"--------------- Starting NoSys ---------------")
        self.peers = PeerManager(self)
        self.users = UserManager(self)

        self.config = Config()
        self.data = DataManager(self)
        self.connections = ConnectionManager(self)
        self.dispatcher = Dispatcher(self)
        self.servers = ServerManager(self)

        self.modules = ModuleManager(self)
        self.modules.setup()
        
        self.fire_event(Events.READY)
        # self.test()

    def restart_app(self):
        logger.warning("Restarting...")
        os.execv(sys.executable, [sys.executable] + sys.argv)

    # ------------------------------------------------------------------------------------------

    def wait_user(self):
        while True:
            if self.users.users:
                user_id = random.choice(list(self.users.users.keys()))
                break
            time.sleep(1)
        return user_id

    def test_connection(self, user_id):
        p1= random.randint(46600, 49000)
        p2 = random.randint(46600, 49000)
        c1 = self.connections.connect(("127.0.0.1", p1), user_id, ("127.0.0.1", p2))
        c2 = self.connections.connect(("127.0.0.1", p2), user_id, ("127.0.0.1", p1))

        p1 = self.peers.get_peer(c1)
        p2 = self.peers.get_peer(c2)

        return p1,p2
    
    def test_rendezvous(self, user_id):
        from libs.rendezvous.rendezvousServer import RendezvousServer
        rendezvous_server : RendezvousServer = self.modules.get("rendezvous", "rendezvousServer")
        rendezvous_server.run_server(user_id)

        time.sleep(2)

        from libs.rendezvous.rendezvousClient import RendezvousClient
        rendezvous_client : RendezvousClient = self.modules.get("rendezvous", "rendezvousClient")
        rendezvous_client.connect_to_server(("localhost", 40441), user_id)
        rendezvous_client.connect_to_server(("localhost", 40441), user_id)

    def test_nosys(self):
        pass

    def test(self):
        from .noSys import NoSys
        nosys : NoSys = self.modules.get("noSys", "noSys")

        # try:
        #     self.data.add_rendezvous("r1", "127.0.0.1:40441")
        # except:
        #     pass
        # try:
        #     net = self.data.create_network("test", "network for tests", "open_forum", [nosys.name])
        # except:
        #     pass
        # self.data.network_assign_rendezvous(net.get("id"), "r1")

        user_id = self.wait_user()

        from libs.rendezvous.rendezvousServer import RendezvousServer
        rendezvous_server : RendezvousServer = self.modules.get("rendezvous", "rendezvousServer")
        rendezvous_server.run_server(user_id)
        # time.sleep(2)
        # self.data.user_add_network(user_id, "629985fd999a675072a2e3f22f74e60c62e8c5b8efb21478c9b04e7ff2fe9779")

        # peer1, peer2 = self.test_connection(user_id)


    #     from libs.fileTransfer.fileTransfer import FileTransfer
    #     file_transfer:FileTransfer = self.modules[("fileTransfer", "fileTransfer")]
    #     file_transfer.subscribe_module_file_events(self.module_id, self.on_file_event)

    #     file_transfer.send_file(r"C:\Users\lucas\Videos\Captures\​C​a​l​l​ ​o​f​ ​D​u​t​y​®​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​ 2025-07-25 10-23-55.mp4", c2, self.module_id)

    # def on_file_event(self, event):
    #     from libs.fileTransfer.fileTransfer import File, FileEvents
    #     file:File = event.file
    #     file.subscribe_event(FileEvents.ON_FILE_COMPLETED.name, self.on_file_done)
    #     file.subscribe_event(FileEvents.ON_FILE_ERROR.name, self.on_file_done)
    #     file.subscribe_event(FileEvents.ON_FILE_UPDATE.name, self.on_file_update)
    #     file.approve_transfer(True)
    
    # def on_file_done(self, event):
    #     logger.warning(f"FILE COMPLETED, DO SOMETHING {event.source.__dict__}")
    
    # def on_file_update(self, event):
    #     file = event.source
    #     total_true = sum(bool(x) for x in file.parts)
    #     logger.warning(f"FILE UPDATE, {total_true}|{len(file.parts)}")