from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from database import insert_virtual_machine, fetch_all
import requests
import os
from datetime import datetime, timezone
import logging

router = APIRouter()
logger = logging.getLogger(__name__)

class VirtualMachine(BaseModel):
    name: str
    location: str
    cpu: int
    memory: str
    storage: str
    type: str

@router.get("/vm/data")
def get_vm_data():
    return {"virtual_machines": fetch_all("virtual_machines")}

@router.post("/vm/data")
def add_vm_data(vm: VirtualMachine):
    existing_vms = fetch_all("virtual_machines")
    if any(existing_vm[1] == vm.name for existing_vm in existing_vms):
        return {"message": f"Virtual machine '{vm.name}' already exists."}
    
    insert_virtual_machine(
        name=vm.name,
        location=vm.location,
        cpu=vm.cpu,
        memory=vm.memory,
        storage=vm.storage,
        vm_type=vm.type
    )
    return {"message": f"Virtual machine '{vm.name}' added successfully."}

@router.get("/vm/import-hetzner")
def import_hetzner_vms(api_token: str = None):
    """
    Import virtual machines from Hetzner Cloud.
    """
    # Check for Hetzner token
    api_token = api_token or os.getenv("HETZNER_TOKEN")
    if not api_token:
        logger.warning("HETZNER_TOKEN is not set. Unable to fetch Hetzner servers.")
        return {"message": "HETZNER_TOKEN is not set. Please set it to fetch servers from Hetzner."}

    hetzner_url = "https://api.hetzner.cloud/v1/servers"
    headers = {"Authorization": f"Bearer {api_token}"}

    try:
        response = requests.get(hetzner_url, headers=headers)
        response.raise_for_status()
    except requests.RequestException as e:
        raise HTTPException(status_code=500, detail=f"Failed to fetch data from Hetzner API: {e}")

    servers = response.json().get("servers", [])
    if not servers:
        return {"message": "No servers found on Hetzner Cloud."}

    # Fetch existing VMs from the database
    existing_vms = {vm[1] for vm in fetch_all("virtual_machines")}

    imported_count = 0
    for server in servers:
        try:
            name = server["name"]
            if name in existing_vms:
                logger.info(f"Skipping existing virtual machine: {name}")
                continue

            location = server["datacenter"]["location"]["name"]
            cpu = server["server_type"]["cores"]
            memory = f"{server['server_type']['memory']} GB"
            storage = f"{server['server_type']['disk']} GB"
            vm_type = server["server_type"]["name"]

            insert_virtual_machine(
                name=name,
                location=location,
                cpu=cpu,
                memory=memory,
                storage=storage,
                vm_type=vm_type
            )
            imported_count += 1
        except Exception as e:
            logger.error(f"Failed to import server {server['name']}: {e}")

    return {"message": f"Imported {imported_count} new virtual machines from Hetzner."}