#!/usr/bin/env python3
"""
AIVA Task CLI - Quick task management for Genesis orchestration.

Usage:
    python aiva_task.py add "Build voice dashboard" --priority 2
    python aiva_task.py list
    python aiva_task.py status
    python aiva_task.py clear-completed
"""

import os
import sys
import json
import argparse
from pathlib import Path
from datetime import datetime

# Load secrets first
secrets_path = Path("/mnt/e/genesis-system/config/secrets.env")
if secrets_path.exists():
    with open(secrets_path) as f:
        for line in f:
            if "=" in line and not line.startswith("#"):
                key, value = line.strip().split("=", 1)
                os.environ[key] = value.strip('"')

import redis

# Redis config
REDIS_CONFIG = {
    "host": os.environ.get("GENESIS_REDIS_HOST", "redis-genesis-u50607.vm.elestio.app"),
    "port": int(os.environ.get("GENESIS_REDIS_PORT", 26379)),
    "password": os.environ.get("GENESIS_REDIS_PASSWORD", ""),
    "decode_responses": True,
}

QUEUE_KEY = "genesis:task_queue"
ACTIVE_KEY = "genesis:active_tasks"
COMPLETED_KEY = "genesis:completed_tasks"
FAILED_KEY = "genesis:failed_tasks"


def get_redis():
    """Get Redis connection."""
    return redis.Redis(**REDIS_CONFIG)


def add_task(title: str, description: str = "", priority: int = 3, max_iterations: int = 30):
    """Add a task to the queue."""
    r = get_redis()

    import hashlib
    import time

    task_id = hashlib.md5(f"{title}{time.time()}".encode()).hexdigest()[:12]

    task = {
        "id": task_id,
        "title": title,
        "description": description or title,
        "priority": priority,
        "status": "pending",
        "created_at": datetime.now().isoformat(),
        "max_iterations": max_iterations,
        "context_files": [],
        "success_criteria": [],
    }

    # Add to sorted set (priority queue)
    score = priority * 1000000 + time.time()
    r.zadd(QUEUE_KEY, {json.dumps(task): score})

    print(f"✅ Added task: {task_id}")
    print(f"   Title: {title}")
    print(f"   Priority: {priority} (1=critical, 5=background)")
    return task_id


def list_tasks():
    """List all tasks."""
    r = get_redis()

    print("\n📋 GENESIS TASK QUEUE")
    print("=" * 60)

    # Pending
    pending = r.zrange(QUEUE_KEY, 0, -1, withscores=True)
    print(f"\n⏳ PENDING ({len(pending)}):")
    for task_json, score in pending:
        task = json.loads(task_json)
        print(f"   [{task['id']}] P{task['priority']} - {task['title'][:40]}")

    # Active
    active = r.hgetall(ACTIVE_KEY)
    print(f"\n🔄 ACTIVE ({len(active)}):")
    for task_id, task_json in active.items():
        task = json.loads(task_json)
        print(f"   [{task_id}] {task['title'][:40]} → {task.get('assigned_to', '?')}")

    # Completed (last 5)
    completed = r.hgetall(COMPLETED_KEY)
    print(f"\n✅ COMPLETED ({len(completed)}) - last 5:")
    completed_list = sorted(
        [json.loads(t) for t in completed.values()],
        key=lambda x: x.get('completed_at', ''),
        reverse=True
    )[:5]
    for task in completed_list:
        print(f"   [{task['id']}] {task['title'][:40]}")

    # Failed
    failed = r.hgetall(FAILED_KEY)
    print(f"\n❌ FAILED ({len(failed)}):")
    for task_id, task_json in list(failed.items())[:5]:
        task = json.loads(task_json)
        print(f"   [{task_id}] {task['title'][:30]} - {task.get('error', 'unknown')[:20]}")

    print("\n" + "=" * 60)


def get_status():
    """Get orchestrator status."""
    r = get_redis()

    heartbeat = r.get("genesis:aiva_heartbeat")

    print("\n🤖 AIVA ORCHESTRATOR STATUS")
    print("=" * 60)

    if heartbeat:
        hb = json.loads(heartbeat)
        print(f"   Status: 🟢 ALIVE")
        print(f"   Last heartbeat: {hb.get('timestamp', 'unknown')}")
        print(f"   PID: {hb.get('pid', 'unknown')}")
    else:
        print(f"   Status: 🔴 OFFLINE")

    print(f"\n   Queue Stats:")
    print(f"     Pending:   {r.zcard(QUEUE_KEY)}")
    print(f"     Active:    {r.hlen(ACTIVE_KEY)}")
    print(f"     Completed: {r.hlen(COMPLETED_KEY)}")
    print(f"     Failed:    {r.hlen(FAILED_KEY)}")

    print("\n" + "=" * 60)


def clear_completed():
    """Clear completed tasks."""
    r = get_redis()
    count = r.hlen(COMPLETED_KEY)
    r.delete(COMPLETED_KEY)
    print(f"🗑️  Cleared {count} completed tasks")


def clear_failed():
    """Clear failed tasks."""
    r = get_redis()
    count = r.hlen(FAILED_KEY)
    r.delete(FAILED_KEY)
    print(f"🗑️  Cleared {count} failed tasks")


def main():
    parser = argparse.ArgumentParser(description="AIVA Task CLI")
    subparsers = parser.add_subparsers(dest="command", help="Command")

    # Add task
    add_parser = subparsers.add_parser("add", help="Add a task")
    add_parser.add_argument("title", help="Task title")
    add_parser.add_argument("-d", "--description", default="", help="Task description")
    add_parser.add_argument("-p", "--priority", type=int, default=3,
                           help="Priority 1-5 (1=critical)")
    add_parser.add_argument("-i", "--iterations", type=int, default=30,
                           help="Max iterations")

    # List
    subparsers.add_parser("list", help="List all tasks")

    # Status
    subparsers.add_parser("status", help="Get orchestrator status")

    # Clear
    subparsers.add_parser("clear-completed", help="Clear completed tasks")
    subparsers.add_parser("clear-failed", help="Clear failed tasks")

    args = parser.parse_args()

    if args.command == "add":
        add_task(args.title, args.description, args.priority, args.iterations)
    elif args.command == "list":
        list_tasks()
    elif args.command == "status":
        get_status()
    elif args.command == "clear-completed":
        clear_completed()
    elif args.command == "clear-failed":
        clear_failed()
    else:
        parser.print_help()


if __name__ == "__main__":
    main()