#!/usr/bin/env python3
"""
SAL-v4 Harness Interactive Interface
Tests different thinking modes and provides multi-turn chat.
"""

import os
import sys
import time
import threading
from datetime import datetime
from pathlib import Path

sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

ENV_FILE = Path(__file__).parent / ".env"
if ENV_FILE.exists():
    with open(ENV_FILE) as f:
        for line in f:
            line = line.strip()
            if line and "=" in line and not line.startswith("#"):
                key, val = line.split("=", 1)
                os.environ.setdefault(key, val)

from core.zai_client import ZAiClient
from core.model_pool import SLOT_SUMMARY


class Spinner:
    """Simple loading spinner."""

    def __init__(self):
        self.running = False
        self.chars = "|/-\\"

    def start(self):
        self.running = True

        def spin():
            i = 0
            while self.running:
                sys.stdout.write(f"\r[{self.chars[i % 4]}] Thinking...")
                sys.stdout.flush()
                time.sleep(0.1)
                i += 1

        self.thread = threading.Thread(target=spin)
        self.thread.start()

    def stop(self):
        self.running = False
        if hasattr(self, "thread"):
            self.thread.join()
        sys.stdout.write("\r" + " " * 30 + "\r")
        sys.stdout.flush()


class ChatSession:
    """Multi-turn chat session with preserved thinking."""

    def __init__(self, api_key: str, model: str = "glm-4.7-flash"):
        self.api_key = api_key
        self.model = model
        self.history = []
        self.thinking_enabled = True
        self.preserve_thinking = True
        self.show_thinking = True
        self.spinner = Spinner()

    def toggle_thinking(self):
        self.thinking_enabled = not self.thinking_enabled
        return self.thinking_enabled

    def toggle_preserve(self):
        self.preserve_thinking = not self.preserve_thinking
        return self.preserve_thinking

    def toggle_show_thinking(self):
        self.show_thinking = not self.show_thinking
        return self.show_thinking

    def clear(self):
        self.history = []

    def chat(self, message: str) -> tuple:
        """Send message and return (content, reasoning)."""

        thinking_config = None
        if self.thinking_enabled:
            thinking_config = {
                "type": "enabled",
                "clear_thinking": not self.preserve_thinking,
            }

        messages = self.history.copy()
        messages.append({"role": "user", "content": message})

        reasoning_parts = []
        content_parts = []

        with ZAiClient(self.api_key, timeout=60.0) as client:
            self.spinner.start()

            try:
                for r_chunk, c_chunk in client.chat_stream(
                    model=self.model,
                    messages=messages,
                    thinking=thinking_config,
                    max_tokens=2048,
                ):
                    if r_chunk:
                        reasoning_parts.append(r_chunk)
                    if c_chunk:
                        content_parts.append(c_chunk)

            finally:
                self.spinner.stop()

            full_reasoning = "".join(reasoning_parts)
            full_content = "".join(content_parts)

            if self.preserve_thinking and full_reasoning:
                self.history.append({"role": "user", "content": message})
                self.history.append(
                    {
                        "role": "assistant",
                        "content": full_content,
                        "reasoning_content": full_reasoning,
                    }
                )
            else:
                self.history.append({"role": "user", "content": message})
                self.history.append({"role": "assistant", "content": full_content})

            return full_content, full_reasoning


def print_banner():
    print("\n" + "=" * 60)
    print("  SAL-v4 Harness - Interactive Chat Interface")
    print("=" * 60)
    print("""
Commands:
  /thinking    - Toggle thinking mode (default: ON)
  /preserve    - Toggle preserved thinking (default: ON)  
  /show        - Toggle showing thinking output (default: ON)
  /clear       - Clear conversation history
  /status      - Show current settings
  /pool        - Show model pool configuration
  /quit        - Exit

Thinking Modes:
  OFF          - Direct response, no reasoning
  ON           - Shows reasoning process
  ON+Preserve  - Keeps reasoning in context for multi-turn
""")
    print("=" * 60 + "\n")


def main():
    api_key = os.environ.get("ZAI_API_KEY")
    if not api_key:
        print("ERROR: ZAI_API_KEY environment variable not set")
        print("\nUsage: ZAI_API_KEY=your-key python chat.py")
        sys.exit(1)

    print_banner()

    session = ChatSession(api_key)

    print(f"Model: {session.model}")
    print(f"Thinking: {'ON' if session.thinking_enabled else 'OFF'}")
    print(f"Preserve: {'YES' if session.preserve_thinking else 'NO'}")
    print(f"Show Thinking: {'YES' if session.show_thinking else 'NO'}")
    print()

    while True:
        try:
            user_input = input("You> ").strip()
            if not user_input:
                continue

            if user_input.startswith("/"):
                cmd = user_input[1:].lower()

                if cmd in ("quit", "exit", "q"):
                    print("Goodbye!")
                    break

                elif cmd == "thinking":
                    state = session.toggle_thinking()
                    print(f"[Thinking: {'ON' if state else 'OFF'}]")

                elif cmd == "preserve":
                    state = session.toggle_preserve()
                    print(f"[Preserve: {'YES' if state else 'NO'}]")

                elif cmd == "show":
                    state = session.toggle_show_thinking()
                    print(f"[Show Thinking: {'YES' if state else 'NO'}]")

                elif cmd == "clear":
                    session.clear()
                    print("[History cleared]")

                elif cmd == "status":
                    print(f"\nModel: {session.model}")
                    print(f"Thinking: {'ON' if session.thinking_enabled else 'OFF'}")
                    print(f"Preserve: {'YES' if session.preserve_thinking else 'NO'}")
                    print(f"Show Thinking: {'YES' if session.show_thinking else 'NO'}")
                    print(f"History turns: {len(session.history) // 2}")
                    print()

                elif cmd == "pool":
                    print(SLOT_SUMMARY)

                elif cmd == "help":
                    print_banner()

                else:
                    print(f"Unknown command: /{cmd}")

                continue

            content, reasoning = session.chat(user_input)

            if reasoning and session.show_thinking:
                print(f"\n[Thinking]\n{reasoning}\n")

            print(f"[Response]\n{content}\n")

        except KeyboardInterrupt:
            print("\n[Interrupted - type /quit to exit]")

        except Exception as e:
            print(f"\n[ERROR] {e}\n")


if __name__ == "__main__":
    main()