import logging
import sys

from tmtccmd.com_if import ComInterface
from tmtccmd.logging import get_current_time_string
from tmtccmd.pus.pus_11_tc_sched import Subservices as Pus11Subservices
from tmtccmd.util import FileSeqCountProvider, PusFileSeqCountProvider
from tmtccmd.util.tmtc_printer import FsfwTmTcPrinter

try:
    import spacepackets
except ImportError as error:
    print(error)
    print("Python tmtccmd module could not be imported. Make sure it is installed")
    sys.exit(1)

try:
    import tmtccmd
except ImportError as error:
    print(error)
    print("Python tmtccmd module could not be imported. Make sure it is installed")
    sys.exit(1)

from spacepackets.ecss import PusVerificator, PusTelecommand

from common_tmtc.pus_tc.pus_11_tc_sched import pack_service_11_commands
from common_tmtc.pus_tc.pus_17_test import pack_service_17_commands
from common_tmtc.pus_tc.pus_200_mode import pack_service_200_commands_into
from common_tmtc.pus_tc.service_20_parameters import pack_service20_commands_into
from common_tmtc.pus_tc.service_2_raw_cmd import pack_service_2_commands_into
from common_tmtc.pus_tc.service_3_housekeeping import pack_service_3_commands_into
from common_tmtc.pus_tc.service_8_func_cmd import pack_service_8_commands_into
from examples.tmtcc import EXAMPLE_APID
from tmtccmd import TcHandlerBase, get_console_logger, TmTcCfgHookBase, BackendBase
from tmtccmd.pus import VerificationWrapper
from tmtccmd.tc import (
    ProcedureHelper,
    FeedWrapper,
    TcProcedureType,
    QueueEntryHelper,
    TcQueueEntryType,
    SendCbParams,
)
from tmtccmd.tc.pus_5_event import pack_generic_service_5_test_into
from tmtccmd.tm import SpecificApidHandlerBase, CcsdsTmHandler
from tmtccmd.logging.pus import RawTmtcTimedLogWrapper
from tmtccmd.config import CoreServiceList, SetupWrapper, SetupParams, ArgParserWrapper
from common_tmtc.config import __version__
from common_tmtc.pus_tm.factory_hook import pus_factory_hook


LOGGER = get_console_logger()


class PusHandler(SpecificApidHandlerBase):
    def __init__(
        self,
        wrapper: VerificationWrapper,
        printer: FsfwTmTcPrinter,
        raw_logger: RawTmtcTimedLogWrapper,
    ):
        super().__init__(EXAMPLE_APID, None)
        self.printer = printer
        self.verif_wrapper = wrapper
        self.raw_logger = raw_logger

    def handle_tm(self, packet: bytes, _user_args: any):
        pus_factory_hook(
            packet=packet,
            wrapper=self.verif_wrapper,
            raw_logger=self.raw_logger,
            printer=self.printer,
        )


class TcHandler(TcHandlerBase):
    def __init__(
        self,
        seq_count_provider: FileSeqCountProvider,
        pus_verificator: PusVerificator,
        file_logger: logging.Logger,
        raw_logger: RawTmtcTimedLogWrapper,
    ):
        super().__init__()
        self.seq_count_provider = seq_count_provider
        self.pus_verificator = pus_verificator
        self.file_logger = file_logger
        self.raw_logger = raw_logger

    def feed_cb(self, info: ProcedureHelper, wrapper: FeedWrapper):
        if info.proc_type == TcProcedureType.DEFAULT:
            def_proc = info.to_def_procedure()
            service = def_proc.service
            op_code = def_proc.op_code
            if service == CoreServiceList.SERVICE_2.value:
                return pack_service_2_commands_into(
                    op_code=op_code, q=wrapper.queue_helper
                )
            if service == CoreServiceList.SERVICE_3.value:
                return pack_service_3_commands_into(
                    op_code=op_code, q=wrapper.queue_helper
                )
            if service == CoreServiceList.SERVICE_5.value:
                return pack_generic_service_5_test_into(q=wrapper.queue_helper)
            if service == CoreServiceList.SERVICE_8.value:
                return pack_service_8_commands_into(
                    op_code=op_code, q=wrapper.queue_helper
                )
            if service == CoreServiceList.SERVICE_11.value:
                return pack_service_11_commands(op_code=op_code, q=wrapper.queue_helper)
            if service == CoreServiceList.SERVICE_17.value:
                return pack_service_17_commands(op_code=op_code, q=wrapper.queue_helper)
            if service == CoreServiceList.SERVICE_20.value:
                return pack_service20_commands_into(
                    q=wrapper.queue_helper, op_code=op_code
                )
            if service == CoreServiceList.SERVICE_200.value:
                return pack_service_200_commands_into(
                    q=wrapper.queue_helper, op_code=op_code
                )
            LOGGER.warning("Invalid Service !")

    def send_cb(self, params: SendCbParams):
        if params.entry.is_tc:
            if params.entry.entry_type == TcQueueEntryType.PUS_TC:
                self.handle_tc_send_cb(params)
        elif params.entry.entry_type == TcQueueEntryType.LOG:
            LOGGER.info(params.entry.to_log_entry().log_str)

    def handle_tc_send_cb(self, params: SendCbParams):
        pus_tc_wrapper = params.entry.to_pus_tc_entry()
        # TODO: All of this stuff should be done during queue insertion time
        #       This requires the queue helper to be optionally able to perform TC
        #       post-processing via a callback or something similar. Then an API can be
        #       added which is also able to pack time tagged TCs and stamping both TCs
        pus_tc_wrapper.pus_tc.seq_count = (
            self.seq_count_provider.get_and_increment()
        )
        pus_tc_wrapper.pus_tc.apid = EXAMPLE_APID
        if (
                pus_tc_wrapper.pus_tc.service == 11
                and pus_tc_wrapper.pus_tc.subservice == Pus11Subservices.TC_INSERT
        ):
            try:
                pus_tc = PusTelecommand.unpack(
                    pus_tc_wrapper.pus_tc.app_data[4:]
                )
                self.pus_verificator.add_tc(pus_tc)
            except ValueError as e:
                LOGGER.warning(
                    f"Attempt of unpacking time tagged TC failed with exception {e}"
                )
        # Add TC after Sequence Count stamping
        self.pus_verificator.add_tc(pus_tc_wrapper.pus_tc)
        raw_tc = pus_tc_wrapper.pus_tc.pack()
        self.raw_logger.log_tc(pus_tc_wrapper.pus_tc)
        tc_info_string = f"Sent {pus_tc_wrapper.pus_tc}"
        LOGGER.info(tc_info_string)
        self.file_logger.info(
            f"{get_current_time_string(True)}: {tc_info_string}"
        )
        params.com_if.send(raw_tc)

    def queue_finished_cb(self, info: ProcedureHelper):
        if info is not None and info.proc_type == TcQueueEntryType.PUS_TC:
            def_proc = info.to_def_procedure()
            LOGGER.info(
                f"Finished queue for service {def_proc.service} and op code {def_proc.op_code}"
            )


def setup_params(hook_obj: TmTcCfgHookBase) -> SetupWrapper:
    print(f"-- eive TMTC Commander --")
    print(f"-- spacepackets v{spacepackets.__version__} --")
    params = SetupParams()
    parser_wrapper = ArgParserWrapper(hook_obj)
    parser_wrapper.parse()
    tmtccmd.init_printout(parser_wrapper.use_gui)
    parser_wrapper.set_params(params)
    params.apid = EXAMPLE_APID
    setup_wrapper = SetupWrapper(hook_obj=hook_obj, setup_params=params)
    return setup_wrapper


def setup_tmtc_handlers(
    verif_wrapper: VerificationWrapper,
    printer: FsfwTmTcPrinter,
    raw_logger: RawTmtcTimedLogWrapper,
) -> (CcsdsTmHandler, TcHandler):

    pus_handler = PusHandler(
        printer=printer, raw_logger=raw_logger, wrapper=verif_wrapper
    )
    ccsds_handler = CcsdsTmHandler(None)
    ccsds_handler.add_apid_handler(pus_handler)
    tc_handler = TcHandler(
        file_logger=printer.file_logger,
        raw_logger=raw_logger,
        pus_verificator=verif_wrapper.pus_verificator,
        seq_count_provider=PusFileSeqCountProvider(),
    )
    return ccsds_handler, tc_handler


def setup_backend(
    setup_wrapper: SetupWrapper,
    tc_handler: TcHandler,
    ccsds_handler: CcsdsTmHandler,
) -> BackendBase:
    tmtc_backend = tmtccmd.create_default_tmtc_backend(
        setup_wrapper=setup_wrapper, tm_handler=ccsds_handler, tc_handler=tc_handler
    )
    tmtccmd.start(tmtc_backend=tmtc_backend, hook_obj=setup_wrapper.hook_obj)
    return tmtc_backend