use axum::{ 
    extract::{Json, State}, 
    response::IntoResponse,
    http
};
use integr_structs::api::v3::PrometheusMetrics;
use prometheus::{Encoder, Registry, TextEncoder, Gauge};
use std::sync::{Arc, MutexGuard};
use crate::AppState;
// use log::{warn, info, error};
use tracing::{info, error, warn};
use crate::metrics::{MetricsProcesser, MetricsValueType};

pub async fn update_metrics(
    State(state): State<Arc<AppState>>,
    Json(request) : Json<PrometheusMetrics>
) -> impl IntoResponse {
    info!("post on /update");
//     let resp = Response::new("body");
    // println!("{:?}", request);
    // debug!("{:?}", MetricsProcesser::get_type_of_value(&request));
    let service = &request.service_name;
    let endpoint = &request.endpoint_name;

    for i in request.metrics {
        // debug!("{:?}", &i);
        // debug!("{:?}", MetricsProcesser::get_type_of_value(&i));
        let metric_name = format!("{}_{}_{}", service, endpoint, &i.id);
        match MetricsProcesser::get_type_of_value(&i) {
            MetricsValueType::Array | 
            MetricsValueType::TaggedArray => {

            },
            MetricsValueType::Number => {
                let gauge = MetricsProcesser::gauge_from_number(
                    &i, 
                    &metric_name
                );
                if let Some(gauge) = gauge {
                    match state.registry.lock() {
                        Err(er) => {
                            error!("Cannot lock Metric Registry due to {} ", er)
                        },
                        Ok(registry) => {
                            update_or_insert_metric(
                                gauge, 
                                registry,
                                &metric_name
                            );
                        },
                    }
                }
                // dbg!(gauge);
            },
            MetricsValueType::ArrayOfStrings => {
                warn!("String arrays are unsupported, ignoring ...");
            },
            _ => {
                warn!("Unrecognized metric type was supplied, ignoring ...");
            }
        }
    }

    (http::StatusCode::ACCEPTED, "Ok")
}

pub async fn metrics_handler(State(state): State<Arc<AppState>>) -> String {
    let registry = state.registry.lock();
    
    return match registry {
        Ok(registry) => {
            let encoder = TextEncoder::new();
            let mut buffer = Vec::new();
            let metric_families = registry.gather();
            encoder.encode(&metric_families, &mut buffer).unwrap();
            String::from_utf8(buffer).unwrap()
        },
        Err(er) => {
            format!("Cannot lock Metric Registry due to {} ", er)
        } 
    }
}

pub fn update_or_insert_metric<'a>(
    metric: Gauge, 
    registry: MutexGuard<'a, Registry>,
    metric_name: &str
) {
    // let mut counter = 0;
    match registry.register(Box::new(metric)) {
        Ok(_) => {
            info!("Metric `{}` was added!", metric_name);
        },
        Err(_er) => {
            // update
        },
    }
    // registry.gather()
    //     .iter()
    //     .filter(|fam| fam.get_name().)
         
}