use std::sync::Arc;

use log::info;
use redis::TypedCommands;
use serde::{Deserialize, Serialize};
use tokio::sync::{Mutex, mpsc::Sender};

use crate::{
    app::{DevConfig, invoke_recipe_checkout_request},
    websocket::{
        core::{TxControlMessage, WebsocketMessageResult, safe_deserialize},
        model::{FinalizeFirmwareRequest, WebsocketMessageRequest},
    },
};

#[derive(Debug, Serialize, Deserialize)]
struct PartialFirmwareBuildArg {
    // full tha param
    pub country: String,
    pub files: Vec<String>,
}

pub async fn handle_request_firmware(
    http_client: &reqwest::Client,
    config: DevConfig,
    mut redis: redis::Client,
    tx: Sender<TxControlMessage>,
    req: WebsocketMessageRequest,
    uid_clone: Arc<Mutex<String>>,
) -> WebsocketMessageResult {
    let p = req.payload.unwrap();
    let req_build_firmware: FinalizeFirmwareRequest = safe_deserialize(&p)?;

    let country = req_build_firmware.country;

    // channel for each country
    let channel_build = format!("build/{country}");

    info!(
        "request building firmware from {}",
        req_build_firmware.requester_info
    );

    let firmware_request_param = PartialFirmwareBuildArg {
        country,
        param: "".to_string(),
    };
    let _ = redis.publish(
        channel_build,
        serde_json::to_string(&firmware_request_param)?,
    );

    match invoke_recipe_checkout_request(
        &http_client,
        config,
        format!("{country}/last_build_release_date"),
    )
    .await
    {
        Ok(last_build) => {
            if let Ok(date) = chrono::DateTime::parse_from_str(&last_build, LAST_BUILD_DATE_FORMAT)
            {
            } else {
            }
        }
        Err(e) => {}
    }

    // TODO
    // - filter files by date from repo
    // - grep file path by filtered
    // NOTE: we must have index init data for every country, must set somewhere.

    Ok(())
}