"""Worker cmdlet: Display workers table in ResultTable format."""
from __future__ import annotations

from typing import Any, Dict, Sequence, List
import json
import sys
from datetime import datetime, timezone

from . import register
from ._shared import Cmdlet, CmdletArg
import pipeline as ctx
from helper.logger import log
from config import get_local_storage_path


CMDLET = Cmdlet(
    name=".worker",
    summary="Display workers table in result table format.",
    usage=".worker [status] [-limit N] [@N]",
    args=[
        CmdletArg("status", description="Filter by status: running, completed, error (default: all)"),
        CmdletArg("limit", type="integer", description="Limit results (default: 100)"),
        CmdletArg("@N", description="Select worker by index (1-based) and display full logs"),
    ],
    details=[
        "- Shows all background worker tasks and their output",
        "- Can filter by status: running, completed, error",
        "- Search result stdout is captured from each worker",
        "- Use @N to select a specific worker by index and display its full logs",
        "Examples:",
        ".worker                        # Show all workers",
        ".worker running                # Show running workers only",
        ".worker completed -limit 50    # Show 50 most recent completed workers",
        ".worker @3                     # Show full logs for the 3rd worker",
        ".worker running @2             # Show full logs for the 2nd running worker",
    ],
)


@register([".worker", "worker", "workers"])
def _run(result: Any, args: Sequence[str], config: Dict[str, Any]) -> int:
	"""Display workers table or show detailed logs for a specific worker."""
	args_list = [str(arg) for arg in (args or [])]
	selection_indices = ctx.get_last_selection()
	selection_requested = bool(selection_indices) and isinstance(result, list) and len(result) > 0

	# Parse arguments for list view
	status_filter: str | None = None
	limit = 100
	clear_requested = False
	worker_id_arg: str | None = None
	i = 0
	while i < len(args_list):
		arg = args_list[i]
		low = arg.lower()
		if low in {"-limit", "--limit"} and i + 1 < len(args_list):
			try:
				limit = max(1, int(args_list[i + 1]))
			except ValueError:
				limit = 100
			i += 2
		elif low in {"-id", "--id"} and i + 1 < len(args_list):
			worker_id_arg = args_list[i + 1]
			i += 2
		elif low in {"-clear", "--clear"}:
			clear_requested = True
			i += 1
		elif low in {"running", "completed", "error", "cancelled"}:
			status_filter = low
			i += 1
		elif not arg.startswith("-"):
			status_filter = low
			i += 1
		else:
			i += 1

	try:
		if any(str(a).lower() in {"-?", "/?", "--help", "-h", "help", "--cmdlet"} for a in args):
			log(json.dumps(CMDLET, ensure_ascii=False, indent=2))
			return 0
	except Exception:
		pass

	library_root = get_local_storage_path(config or {})
	if not library_root:
		log("No library root configured", file=sys.stderr)
		return 1

	try:
		from helper.local_library import LocalLibraryDB
		db: LocalLibraryDB | None = None
		try:
			db = LocalLibraryDB(library_root)
			if clear_requested:
				count = db.clear_finished_workers()
				log(f"Cleared {count} finished workers.")
				return 0
			
			if worker_id_arg:
				worker = db.get_worker(worker_id_arg)
				if worker:
					events = []
					try:
						wid = worker.get("worker_id")
						if wid and hasattr(db, "get_worker_events"):
							events = db.get_worker_events(wid)
					except Exception:
						pass
					_emit_worker_detail(worker, events)
					return 0
				else:
					log(f"Worker not found: {worker_id_arg}", file=sys.stderr)
					return 1

			if selection_requested:
				return _render_worker_selection(db, result)
			return _render_worker_list(db, status_filter, limit)
		finally:
			if db:
				db.close()
	except Exception as exc:
		log(f"Workers query failed: {exc}", file=sys.stderr)
		import traceback
		traceback.print_exc(file=sys.stderr)
		return 1


def _render_worker_list(db, status_filter: str | None, limit: int) -> int:
	workers = db.get_all_workers(limit=limit)
	if status_filter:
		workers = [w for w in workers if str(w.get("status", "")).lower() == status_filter]

	if not workers:
		log("No workers found", file=sys.stderr)
		return 0

	for worker in workers:
		started = worker.get("started_at", "")
		ended = worker.get("completed_at", worker.get("last_updated", ""))
		
		date_str = _extract_date(started)
		start_time = _format_event_timestamp(started)
		end_time = _format_event_timestamp(ended)
		
		item = {
			"columns": [
				("Status", worker.get("status", "")),
				("Pipe", _summarize_pipe(worker.get("pipe"))),
				("Date", date_str),
				("Start Time", start_time),
				("End Time", end_time),
			],
			"__worker_metadata": worker,
			"_selection_args": ["-id", worker.get("worker_id")]
		}
		ctx.emit(item)
	return 0


def _render_worker_selection(db, selected_items: Any) -> int:
	if not isinstance(selected_items, list):
		log("Selection payload missing", file=sys.stderr)
		return 1

	emitted = False
	for item in selected_items:
		worker = _resolve_worker_record(db, item)
		if not worker:
			continue
		events = []
		try:
			events = db.get_worker_events(worker.get("worker_id")) if hasattr(db, "get_worker_events") else []
		except Exception:
			events = []
		_emit_worker_detail(worker, events)
		emitted = True
	if not emitted:
		log("Selected rows no longer exist", file=sys.stderr)
		return 1
	return 0


def _resolve_worker_record(db, payload: Any) -> Dict[str, Any] | None:
	if not isinstance(payload, dict):
		return None
	worker_data = payload.get("__worker_metadata")
	worker_id = None
	if isinstance(worker_data, dict):
		worker_id = worker_data.get("worker_id")
	else:
		worker_id = payload.get("worker_id")
		worker_data = None
	if worker_id:
		fresh = db.get_worker(worker_id)
		if fresh:
			return fresh
	return worker_data if isinstance(worker_data, dict) else None


def _emit_worker_detail(worker: Dict[str, Any], events: List[Dict[str, Any]]) -> None:
	# Parse stdout logs into rows
	stdout_content = worker.get("stdout", "") or ""
	
	# Try to parse lines if they follow the standard log format
	# Format: YYYY-MM-DD HH:MM:SS - name - level - message
	lines = stdout_content.splitlines()
	
	for line in lines:
		line = line.strip()
		if not line:
			continue
			
		# Default values
		timestamp = ""
		level = "INFO"
		message = line
		
		# Try to parse standard format
		try:
			parts = line.split(" - ", 3)
			if len(parts) >= 4:
				# Full format
				ts_str, _, lvl, msg = parts
				timestamp = _format_event_timestamp(ts_str)
				level = lvl
				message = msg
			elif len(parts) == 3:
				# Missing name or level
				ts_str, lvl, msg = parts
				timestamp = _format_event_timestamp(ts_str)
				level = lvl
				message = msg
		except Exception:
			pass
			
		item = {
			"columns": [
				("Time", timestamp),
				("Level", level),
				("Message", message)
			]
		}
		ctx.emit(item)
		
	# Also emit events if available and not redundant
	# (For now, just focusing on stdout logs as requested)


def _summarize_pipe(pipe_value: Any, limit: int = 60) -> str:
	text = str(pipe_value or "").strip()
	if not text:
		return "(none)"
	return text if len(text) <= limit else text[: limit - 3] + "..."


def _format_event_timestamp(raw_timestamp: Any) -> str:
	dt = _parse_to_local(raw_timestamp)
	if dt:
		return dt.strftime("%H:%M:%S")

	if not raw_timestamp:
		return "--:--:--"
	text = str(raw_timestamp)
	if "T" in text:
		time_part = text.split("T", 1)[1]
	elif " " in text:
		time_part = text.split(" ", 1)[1]
	else:
		time_part = text
	return time_part[:8] if len(time_part) >= 8 else time_part


def _parse_to_local(timestamp_str: Any) -> datetime | None:
	if not timestamp_str:
		return None
	text = str(timestamp_str).strip()
	if not text:
		return None

	try:
		# Check for T separator (Python isoformat - Local time)
		if 'T' in text:
			return datetime.fromisoformat(text)
		
		# Check for space separator (SQLite CURRENT_TIMESTAMP - UTC)
		# Format: YYYY-MM-DD HH:MM:SS
		if ' ' in text:
			# Assume UTC
			dt = datetime.strptime(text, "%Y-%m-%d %H:%M:%S")
			dt = dt.replace(tzinfo=timezone.utc)
			return dt.astimezone() # Convert to local
			
	except Exception:
		pass
		
	return None


def _extract_date(raw_timestamp: Any) -> str:
	dt = _parse_to_local(raw_timestamp)
	if dt:
		return dt.strftime("%m-%d-%y")
	
	# Fallback
	if not raw_timestamp:
		return ""
	text = str(raw_timestamp)
	# Extract YYYY-MM-DD part
	date_part = ""
	if "T" in text:
		date_part = text.split("T", 1)[0]
	elif " " in text:
		date_part = text.split(" ", 1)[0]
	else:
		date_part = text
	
	# Convert YYYY-MM-DD to MM-DD-YY
	try:
		parts = date_part.split("-")
		if len(parts) == 3:
			year, month, day = parts
			return f"{month}-{day}-{year[2:]}"
	except Exception:
		pass
	return date_part