import os
import gradio as gr
from typing import List, Tuple, Optional

from src.dataset_client import DatasetAPIClient
from src.state_machine import StateMachine, State, CardType
from src.card_generator import CardGenerator
from src.command_parser import CommandParser


DATASET_ID = os.getenv("MINDSEYE_DATASET", "PeacebinfLow/mindseye-lab-ledger").strip()
DATASET_CONFIG = os.getenv("MINDSEYE_CONFIG", "default").strip()

client = DatasetAPIClient(dataset=DATASET_ID, config=DATASET_CONFIG)
sm = StateMachine()
gen = CardGenerator()
parser = CommandParser()


HELP_TEXT = (
    "Commands:\n"
    "- MODE <STATE> | CARD <TYPE> | RUN <query> | TEST | LEDGER | RESET | STATE | HELP\n\n"
    "Dataset ops:\n"
    "- RUN <query> -> search train\n"
    "- TEST -> first rows\n"
    "- LEDGER -> rows page\n"
)


def process_command(command: str, history: List[Tuple[str, str]]):
    history = history or []
    parsed = parser.parse(command)

    if not parsed["valid"]:
        card = gen.generate_error_card(sm.current_state, parsed.get("error", "Invalid command"))
        history.append((command, card))
        return card, None, history

    result = sm.transition(command)
    dataset_result = None

    cmd = parsed["command"]
    arg = parsed.get("argument") or ""

    # Handle HELP/STATE explicitly
    if cmd == "HELP":
        card = gen.generate(
            state=sm.current_state,
            card_type=CardType.CONCEPT,
            title="Help",
            description="Available commands and usage.",
            content={"HELP": HELP_TEXT, "STATE": sm.current_state.value},
        )
        history.append((command, card))
        return card, {"help": HELP_TEXT}, history

    if cmd == "STATE":
        card = gen.generate(
            state=sm.current_state,
            card_type=CardType.SPEC,
            title="Runtime State",
            description="Current runtime state snapshot.",
            content={"STATE": sm.current_state.value, "HISTORY_DEPTH": len(sm.history)},
        )
        history.append((command, card))
        return card, {"state": sm.current_state.value}, history

    # Dataset query commands
    if cmd == "RUN":
        if arg:
            dataset_result = client.search_dataset(query=arg, split="train")
        else:
            dataset_result = {"error": "RUN requires a query string", "rows": []}

    elif cmd == "TEST":
        dataset_result = client.get_first_rows(split="train", limit=10)

    elif cmd == "LEDGER":
        dataset_result = client.get_rows(split="train", offset=0, length=25)

    # Card type selection
    card_type = sm.get_output_card_type()

    # Build card content depending on action
    if result["action"] == "transition":
        allowed = [ct.value for ct in sm.STATE_CARD_MAPPING[sm.current_state]]
        card = gen.generate(
            state=sm.current_state,
            card_type=card_type,
            title=f"{sm.current_state.value} Module",
            description=f"Entered {sm.current_state.value}",
            content={"STATE_INFO": sm.current_state.value, "AVAILABLE_CARDS": allowed},
            dataset_result=dataset_result,
            context_links=[f"{sm.current_state.value}.overview"],
            next_actions=["RUN <query>", "TEST", "LEDGER", "RESET"],
        )

    elif result["action"] == "query":
        rows = dataset_result.get("rows", []) if isinstance(dataset_result, dict) else []
        card = gen.generate(
            state=sm.current_state,
            card_type=CardType.SPEC,
            title="Dataset Query Results",
            description=f"Query executed: {command}",
            content={"QUERY": command, "RESULTS_COUNT": len(rows), "SAMPLE": rows[:3]},
            dataset_result=dataset_result,
            context_links=["LEDGER_CORE.query_engine"],
            next_actions=["RUN <new-query>", "RESET"],
        )

    elif result["action"] == "filter":
        card = gen.generate(
            state=sm.current_state,
            card_type=CardType.SPEC,
            title="Card Filter Set",
            description=f"Forced card type: {result.get('card_type')}",
            content={"FILTER": result},
            next_actions=["RUN <query>", "MODE <state>", "RESET"],
        )

    elif result["action"] == "reset":
        card = gen.generate(
            state=sm.current_state,
            card_type=CardType.CONCEPT,
            title="Reset",
            description="Returned to CORE_OS and cleared runtime context.",
            content={"RESET": True},
            next_actions=["MODE LEDGER_CORE", "RUN <query>", "HELP"],
        )

    else:
        card = gen.generate(
            state=sm.current_state,
            card_type=card_type,
            title="Command Processed",
            description=f"Action: {result.get('action')}",
            content={"RESULT": result},
            dataset_result=dataset_result,
            next_actions=["HELP", "RESET"],
        )

    history.append((command, card))
    return card, dataset_result, history


with gr.Blocks(title="MindsEye Lab", theme=gr.themes.Monochrome()) as app:
    gr.Markdown(
        "# 🧠 MindsEye Lab - Stateful OS Runtime\n"
        "Deterministic runtime that queries a dataset and emits locked YAML cards.\n\n"
        f"**Dataset:** `{DATASET_ID}`  •  **Config:** `{DATASET_CONFIG}`"
    )

    with gr.Row():
        with gr.Column(scale=3):
            command_input = gr.Textbox(
                label="Command",
                placeholder="MODE LEDGER_CORE | RUN WORKFLOW_ | TEST | LEDGER | RESET",
                lines=1,
            )
        with gr.Column(scale=1):
            submit_btn = gr.Button("Execute", variant="primary")

    gr.Markdown("### Quick Commands")
    with gr.Row():
        gr.Button("MODE LEDGER_CORE").click(lambda: "MODE LEDGER_CORE", None, command_input)
        gr.Button("MODE BUILD_SPACE").click(lambda: "MODE BUILD_SPACE", None, command_input)
        gr.Button("TEST").click(lambda: "TEST", None, command_input)
        gr.Button("LEDGER").click(lambda: "LEDGER", None, command_input)
        gr.Button("RESET").click(lambda: "RESET", None, command_input)

    card_output = gr.Code(label="YAML Card Response", language="yaml", lines=30)

    with gr.Accordion("Dataset Results (Raw JSON)", open=False):
        dataset_output = gr.JSON(label="Query Results")

    chat = gr.Chatbot(label="Session History", height=320)

    submit_btn.click(
        fn=process_command,
        inputs=[command_input, chat],
        outputs=[card_output, dataset_output, chat],
    )

    command_input.submit(
        fn=process_command,
        inputs=[command_input, chat],
        outputs=[card_output, dataset_output, chat],
    )

if __name__ == "__main__":
    app.launch()