# fixed_sync_endpoint.py
from fastapi import APIRouter, Depends
from sqlalchemy.orm import Session
from sqlalchemy import text
from datetime import datetime, timezone
from database import get_db
from activity_categorizer import ActivityCategorizer

router = APIRouter()

@router.post("/api/sync")
async def receive_sync_data(sync_data: dict, db: Session = Depends(get_db)):
    """Sync endpoint saving all activities including duplicates"""
    try:
        token = sync_data.get("token")
        data = sync_data.get("data", [])
        timestamp = sync_data.get("timestamp")
        
        # Validate developer
        developer = db.execute(
            text("SELECT developer_id FROM developers WHERE api_token = :token"),
            {"token": token}
        ).fetchone()
        if not developer:
            return {"error": "Invalid token"}
        developer_id = developer[0]
        
        categorizer = ActivityCategorizer()
        saved_count = 0
        failed_count = 0

        for event in data:
            try:
                event_data = event.get("data", {})
                duration = event.get("duration", 0)
                if duration < 5:  # skip very short activities
                    continue

                event_timestamp = event.get("timestamp", timestamp)
                window_title = event_data.get("title", "Untitled")
                app_name = event_data.get("app", event_data.get("application", "Unknown"))
                url = event_data.get("url", "")
                file_path = event_data.get("file", "")

                # Clean window title
                for suffix in [" - Google Chrome", " - Mozilla Firefox", " - Microsoft Edge", " - Visual Studio Code"]:
                    window_title = window_title.replace(suffix, "")

                category_info = categorizer.get_detailed_category(window_title, app_name)
                print(f"DEBUG: '{window_title[:50]}' -> {category_info}")

                # Make sure it always returns valid data
                if not category_info or not category_info.get("category"):
                    category_info = {
                        "category": "browser" if "chrome" in app_name.lower() else "uncategorized",
                        "subcategory": "general"
                    }
                project_name = extract_project_name(window_title, app_name)

                # Parse timestamp
                if isinstance(event_timestamp, str):
                    parsed_timestamp = datetime.fromisoformat(event_timestamp.replace('Z', '+00:00'))
                else:
                    parsed_timestamp = event_timestamp

                # Insert activity record (duplicates allowed)
                insert_query = text("""
                    INSERT INTO activity_records (
                        developer_id, application_name, window_title,
                        url, file_path, duration, timestamp,
                        category, project_name, project_type,
                        created_at
                    ) VALUES (
                        :developer_id, :application_name, :window_title,
                        :url, :file_path, :duration, :timestamp,
                        :category, :project_name, :project_type,
                        :created_at
                    )
                """)

                db.execute(insert_query, {
                    "developer_id": developer_id,
                    "application_name": app_name[:255],
                    "window_title": window_title[:500],
                    "url": url[:1000] if url else "",
                    "file_path": file_path[:1000] if file_path else "",
                    "duration": int(duration),
                    "timestamp": parsed_timestamp,
                    "category": category_info["category"],
                    "project_name": project_name,
                    "project_type": category_info["subcategory"],
                    "created_at": datetime.now(timezone.utc)
                })
                saved_count += 1

            except Exception as e:
                failed_count += 1
                print(f"Error processing event: {e}")
                continue

        db.commit()
        print(f"✅ Synced {saved_count} activities for {developer_id} (failed: {failed_count})")
        return {
            "success": True,
            "received": len(data),
            "saved": saved_count,
            "failed": failed_count,
            "developer": developer_id
        }

    except Exception as e:
        db.rollback()
        print(f"❌ Sync error: {e}")
        return {"error": str(e), "success": False}

# Project name extraction function
def extract_project_name(window_title: str, app_name: str) -> str:
    import re
    vscode_match = re.search(r' - ([^-]+) - (?:Visual Studio Code|VS Code|Cursor)', window_title)
    if vscode_match:
        return vscode_match.group(1).strip()
    jetbrains_match = re.search(r'^([^–]+) – ', window_title)
    if jetbrains_match and any(ide in app_name.lower() for ide in ['intellij', 'pycharm', 'webstorm']):
        return jetbrains_match.group(1).strip()
    git_match = re.search(r'\\([^\\]+)\\\.git', window_title)
    if git_match:
        return git_match.group(1)
    repo_match = re.search(r'github\.com/[^/]+/([^/\s]+)', window_title)
    if repo_match:
        return repo_match.group(1)
    folder_match = re.search(r'\\([^\\]+)\\[^\\]+\.[a-z]+$', window_title)
    if folder_match:
        return folder_match.group(1)
    return "general"