from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from database import get_db
import models
from pydantic import BaseModel
from datetime import date
from typing import Optional

router = APIRouter()

# Pydantic model for request validation
class ServerBase(BaseModel):
    name: str
    ip_address: str
    dns_name: Optional[str] = None
    guest_os: str
    service_date: Optional[date] = None
    automatic_updates: bool = False
    zabbix: bool = False
    other_info: Optional[str] = None
    server_type: str = 'Virtuaalinen'  # Uusi kenttä

# Pydantic model for OS EOL response
class OsEolResponse(BaseModel):
    os_name: str
    eol_date: date
    extended_eol_date: Optional[date] = None
    notes: Optional[str] = None

@router.get("/api/servers/archived")
def get_archived_servers(db: Session = Depends(get_db)):
    servers = db.query(models.Server).filter(models.Server.archived_date.isnot(None)).all()
    return servers

@router.get("/api/servers")
def get_servers(db: Session = Depends(get_db)):
    servers = db.query(models.Server).filter(models.Server.archived_date.is_(None)).all()
    return servers

@router.put("/api/servers/{server_id}/archive")
def archive_server(server_id: int, db: Session = Depends(get_db)):
    server = db.query(models.Server).filter(models.Server.id == server_id).first()
    if server is None:
        raise HTTPException(status_code=404, detail="Palvelinta ei löytynyt")
    
    server.archived_date = date.today()
    db.commit()
    db.refresh(server)
    return {"message": "Palvelin arkistoitu onnistuneesti"}

@router.post("/api/servers")
def create_server(server: ServerBase, db: Session = Depends(get_db)):
    db_server = models.Server(**server.dict())
    db.add(db_server)
    db.commit()
    db.refresh(db_server)
    return db_server

@router.get("/api/servers/{server_id}")
def get_server(server_id: int, db: Session = Depends(get_db)):
    server = db.query(models.Server).filter(models.Server.id == server_id).first()
    if server is None:
        raise HTTPException(status_code=404, detail="Palvelinta ei löytynyt")
    return server

@router.put("/api/servers/{server_id}")
def update_server(server_id: int, server: ServerBase, db: Session = Depends(get_db)):
    db_server = db.query(models.Server).filter(models.Server.id == server_id).first()
    if db_server is None:
        raise HTTPException(status_code=404, detail="Palvelinta ei löytynyt")
    
    for key, value in server.dict().items():
        setattr(db_server, key, value)
    
    db.commit()
    db.refresh(db_server)
    return db_server

@router.delete("/api/servers/{server_id}")
def delete_server(server_id: int, db: Session = Depends(get_db)):
    server = db.query(models.Server).filter(models.Server.id == server_id).first()
    if server is None:
        raise HTTPException(status_code=404, detail="Palvelinta ei löytynyt")
    
    db.delete(server)
    db.commit()
    return {"message": "Palvelin poistettu"}

@router.get("/api/os-eol/{os_name}", response_model=OsEolResponse)
def get_os_eol(os_name: str, db: Session = Depends(get_db)):
    # Käytetään SQLAlchemya raw SQL:n sijaan
    eol_data = db.query(models.OsEol).filter(models.OsEol.os_name == os_name).first()
    
    if eol_data is None:
        raise HTTPException(status_code=404, detail="Käyttöjärjestelmää ei löytynyt")
    
    return {
        "os_name": eol_data.os_name,
        "eol_date": eol_data.eol_date,
        "extended_eol_date": eol_data.extended_eol_date,
        "notes": eol_data.notes
    }