use actix_web::{get, post, put, web, HttpResponse, Responder};
use log::{error, info};
use sqlx::types::mac_address::MacAddress;

use crate::{schemas::{AppState, DeviceMetadata, TelemetryMessageFromDevice, ValueMessageFromDevice}, util::parse_mac_address};

#[post("/telemetry/{device_id}")]
async fn receive_telemetry(
    device_id: web::Path<String>,
    data: web::Data<AppState>,
    telemetry_message: web::Json<TelemetryMessageFromDevice>,
) -> impl Responder {
    info!("POST - telementry - Processing device id {}", device_id);
    let Ok(mac_converted) = parse_mac_address(&device_id) else {
        return HttpResponse::InternalServerError();
    };
    let mac_converted = MacAddress::from(mac_converted);
    match data.db.create_device_if_not_exists(&mac_converted).await {
        Ok(_) => {}
        Err(e) => {
            error!("Error creating new device: {}", e);
            return HttpResponse::InternalServerError();
        }
    };

    match data
        .db
        .add_telemetry(&telemetry_message, &mac_converted)
        .await
    {
        Ok(_) => HttpResponse::Created(),
        Err(e) => {
            error!("adding Telemetry message to DB failed \n{}", e);
            HttpResponse::InternalServerError()
        }
    }
}

#[get("/telemetry/{device_id}")]
async fn get_telemetry(device_id: web::Path<String>, data: web::Data<AppState>) -> impl Responder {
    info!("GET - telementry - Processing device id {}", device_id);
    let Ok(mac_converted) = parse_mac_address(&device_id) else {
        return HttpResponse::InternalServerError().finish();
    };
    let mac_converted = MacAddress::from(mac_converted);
    let messages = match data.db.get_telemetry_for_id(&mac_converted).await {
        Ok(msgs) => msgs,
        Err(e) => {
            error!("Getting Telemetry Messages from DB failed \n{}", e);
            return HttpResponse::InternalServerError().finish();
        }
    };
    HttpResponse::Ok().json(messages)
}

#[post("/value/{device_id}")]
async fn receive_value(
    device_id: web::Path<String>,
    data: web::Data<AppState>,
    value_message: web::Json<ValueMessageFromDevice>,
) -> impl Responder {
    info!("POST - value - Processing device id {}", device_id);
    let Ok(mac_converted) = parse_mac_address(&device_id) else {
        return HttpResponse::InternalServerError();
    };
    let mac_converted = MacAddress::from(mac_converted);
    match data.db.create_device_if_not_exists(&mac_converted).await {
        Ok(_) => {}
        Err(e) => {
            error!("Error creating new device: {}", e);
            return HttpResponse::InternalServerError();
        }
    };

    match data.db.add_value(&value_message, &mac_converted).await {
        Ok(_) => HttpResponse::Created(),
        Err(e) => {
            error!("adding Telemetry message to DB failed \n{}", e);
            HttpResponse::InternalServerError()
        }
    }
}

#[get("/value/{device_id}")]
async fn get_value(device_id: web::Path<String>, data: web::Data<AppState>) -> impl Responder {
    info!("GET - value - Processing device id {}", device_id);
    let Ok(mac_converted) = parse_mac_address(&device_id) else {
        return HttpResponse::InternalServerError().finish();
    };
    let mac_converted = MacAddress::from(mac_converted);
    let messages = match data.db.get_values_for_id(&mac_converted).await {
        Ok(msgs) => msgs,
        Err(e) => {
            error!("Getting Values from DB failed \n{}", e);
            return HttpResponse::InternalServerError().finish();
        }
    };
    HttpResponse::Ok().json(messages)
}

#[get("/device")]
async fn get_devices(data: web::Data<AppState>) -> impl Responder {
    info!("GET - devices - Processing");
    let devices = match data.db.get_devices().await {
        Ok(devs) => devs,
        Err(e) => {
            error!("Getting Devices from DB failed \n{}", e);
            return HttpResponse::InternalServerError().finish();
        }
    };
    HttpResponse::Ok().json(devices)
}

#[put("/device/{device_id}/display_name")]
async fn set_display_name(data: web::Data<AppState>, device_id: web::Path<String>, device_data: web::Json<DeviceMetadata>) -> impl Responder {
    info!("PUT - device/{device_id} - Display Name", );
    let display_name = device_data.0.display_name;
    let db = &data.db;
    let Ok(mac_converted) = parse_mac_address(&device_id) else {
        error!("Failed to convert mac address");
        return HttpResponse::InternalServerError().finish();
    };
    let mac_converted = MacAddress::from(mac_converted);
    match db.update_display_name(&mac_converted, &display_name).await {
        Ok(_) => HttpResponse::Ok().finish(),
        Err(_) => {
            error!("Failed to update/set displayName for device");
            HttpResponse::InternalServerError().finish()
        }
    }
    

}