import functools
from datetime import datetime
from typing import List

from fastapi import FastAPI, Depends, Query
from enum import Enum

from requests import session
from sqlmodel import Session
from fastapi.middleware.cors import CORSMiddleware

from db import get_session
from models.measurement import IndoorMeasurementCreateRequest, MeasurementListResponse, OutdoorMeasurementCreateRequest, \
    MeasurementResolution, RecordResponse
from models.station import StationCreateRequest, StationCreateResponse, Station, StationListResponse, \
    StationUpdateResponse, StationUpdateRequest
from services import stationService, measurementService

app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["http://localhost:4200"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

@app.get("/stations/list", response_model=List[StationListResponse], status_code=201)
async def list_stations(session: Session = Depends(get_session)):
    result = stationService.list_stations(session)
    return [StationListResponse.model_validate(station) for station in result]

@app.post("/stations/create", response_model=StationCreateResponse, status_code=200)
async def create_station(station_data: StationCreateRequest, session: Session = Depends(get_session)) -> StationCreateResponse:
    station = stationService.create_station(session, station_data)
    return StationCreateResponse.model_validate(station)

@app.patch("/stations/update", response_model=StationUpdateResponse, status_code=200)
async def update_station(station_data: StationUpdateRequest, session: Session = Depends(get_session)):
    station = stationService.update_station(session, station_data)
    return StationUpdateResponse.model_validate(station)

@app.delete("/stations/{station_id}", status_code=204)
async def delete_station(station_id: int, session: Session = Depends(get_session)):
    stationService.delete_station(session, station_id)

@app.post("/measurements/indoor", status_code=204)
async def create_indoor_measurement(data: IndoorMeasurementCreateRequest, session: Session = Depends(get_session)):
    measurementService.push_indoor_measurement(session, data)

@app.post("/measurements/outdoor", status_code=204)
async def create_outdoor_measurement(data: OutdoorMeasurementCreateRequest, session: Session = Depends(get_session)):
    measurementService.push_outdoor_measurement(session, data)
@app.get("/measurements", response_model=MeasurementListResponse, status_code=200)
async def get_measurements(
        station_ids: list[int] | None = Query(default=None),
        indoor: bool | None = Query(default=None),
        from_timestamp: datetime | None = None,
        to_timestamp: datetime | None = None,
        resolution: MeasurementResolution = MeasurementResolution.hourly,
        limit: int | None = None,
        session: Session = Depends(get_session)):
    return measurementService.get_measurements(session, station_ids, indoor, from_timestamp, to_timestamp, limit, resolution)

@app.get('/measurements/records', response_model=RecordResponse, status_code=200)
async def get_records(station_ids: list[int] | None = Query(default=None), from_timestamp: datetime | None = None, session: Session = Depends(get_session)):
    return RecordResponse.model_validate(measurementService.get_measurement_records(session, station_ids, from_timestamp))