from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from core.essentials.observers.ConnectionObserver import ConnectionObserver
    from core.observers.TicketObserver import TicketObserver

from core.services.prepare_tickets.ticket_prep_orchestrator import ticket_prep_orchestrator
from core.services.prepare_tickets.make_sure_pub_key_exists import make_sure_pub_key_exists
from core.services.helpers.get_how_many_profiles_were_ordered import (
    get_how_many_profiles_were_ordered,
)
from core.observers.BaseObserver import BaseObserver

"""
Goal:
this is the controller for the view to speak with the high level "ticket_prep_orchestrator" service function, 
which makes commitments, sends to the server, and then unblinds them, and preps the ticket JSONs.

Requires:
a temp billing ID
having paid already

Doesn't Require:
If it doesn't have the public key, then it checks the config file.
If it doesn't have a config file, then it uses the temp billing id to get the public key from the server.
"""


def prepare_tickets(
    how_many_profiles: int,
    ticket_observer: TicketObserver,
    connection_observer: ConnectionObserver,
) -> dict:

    # make sure it's a number:
    if not isinstance(how_many_profiles, int):
        ticket_observer.notify("failed_input", None)
        return {"valid": False, "error_code": "failed_input"}

    # make sure that "how_many_profiles" is actually the number of profiles ordered
    # (which is based on locally saved data from the previous step):
    how_many_ordered = get_how_many_profiles_were_ordered()
    if how_many_profiles != how_many_ordered:
        ticket_observer.notify("failed_input", None)
        return {"valid": False, "error_code": "failed_input"}

    # make sure this guy has a public key to verify against:
    does_he_have_public_key = make_sure_pub_key_exists(connection_observer)
    if does_he_have_public_key == False:
        ticket_observer.notify("failed_input", None)
        return {"valid": False, "error_code": "failed_input"}

    notification = "Preparing Cryptography Locally"
    ticket_observer.notify("preparing", subject=notification)

    # ok now we have the pre-reqs, let's use this high level orchestrator,
    prep_results = ticket_prep_orchestrator(
        how_many_profiles, ticket_observer, connection_observer
    )

    # rest of this function is evaluating the results:

    if prep_results == False or prep_results == None:
        return {"valid": False, "message": "error"}

    if "valid" not in prep_results:
        return {"valid": False, "message": "error"}

    if prep_results["valid"] == True:
        notification = f"Done! All Tickets Ready!"
        ticket_observer.notify("preparing", subject=notification)
        return prep_results

    if "how_many_failed" in prep_results:
        how_many_failed = prep_results.get("how_many_failed", 0)
        failed_validations = prep_results.get("failed_validations", None)
        if failed_validations:
            notification = f"Error with Ticket Preparation or Verification!"
            ticket_observer.notify("preparing", subject=notification)
            return prep_results

    notification = f"Error with Ticket Preparation or Verification!"
    ticket_observer.notify("preparing", subject=notification)
    return prep_results