//offer ota and config mode

use std::{
    collections::VecDeque,
    io::{BufRead, Read, Write},
    str::from_utf8,
    sync::{atomic::AtomicBool, Arc},
};

use crate::{espota::OtaUpdate, BOARD_ACCESS};
use core::result::Result::Ok;
use embedded_svc::http::{Method};
use esp_idf_hal::delay::Delay;
use esp_idf_svc::http::server::{Configuration, EspHttpServer};
use esp_idf_sys::vTaskDelay;
use heapless::String;
use serde::{Deserialize, Serialize};

use crate::{
    config::{Config, WifiConfig},
    plant_hal::PlantCtrlBoardInteraction,
};

#[derive(Serialize, Debug)]
struct SSIDList<'a> {
    ssids: Vec<&'a String<32>>,
}

#[derive(Serialize, Debug)]
struct VersionInfo<'a> {
    git_hash: &'a str,
    build_time: &'a str,
}

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
pub struct TestPump {
    pump: usize,
}

pub fn httpd_initial(reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
    let mut server = shared();
    server
        .fn_handler("/", Method::Get, move |request| {
            let mut response = request.into_ok_response()?;
            response.write(include_bytes!("initial_config.html"))?;
            anyhow::Ok(())
        })
        .unwrap();

    server
        .fn_handler("/wifiscan", Method::Post, move |request| {
            let mut response = request.into_ok_response()?;
            let mut board = BOARD_ACCESS.lock().unwrap();
            match board.wifi_scan() {
                Err(error) => {
                    response.write(format!("Error scanning wifi: {}", error).as_bytes())?;
                }
                Ok(scan_result) => {
                    let mut ssids: Vec<&String<32>> = Vec::new();
                    scan_result.iter().for_each(|s| ssids.push(&s.ssid));
                    let ssid_json = serde_json::to_string(&SSIDList { ssids })?;
                    println!("Sending ssid list {}", &ssid_json);
                    response.write(ssid_json.as_bytes())?;
                }
            }
            anyhow::Ok(())
        })
        .unwrap();

    server
        .fn_handler("/wifisave", Method::Post, move |mut request| {
            let mut buf = [0_u8; 2048];
            let read = request.read(&mut buf);
            if read.is_err() {
                let error_text = read.unwrap_err().to_string();
                println!("Could not parse wificonfig {}", error_text);
                request
                    .into_status_response(500)?
                    .write(error_text.as_bytes())?;
                return anyhow::Ok(());
            }
            let actual_data = &buf[0..read.unwrap()];
            println!("raw {:?}", actual_data);
            println!("Raw data {}", from_utf8(actual_data).unwrap());
            let wifi_config: Result<WifiConfig, serde_json::Error> =
                serde_json::from_slice(actual_data);
            if wifi_config.is_err() {
                let error_text = wifi_config.unwrap_err().to_string();
                println!("Could not parse wificonfig {}", error_text);
                request
                    .into_status_response(500)?
                    .write(error_text.as_bytes())?;
                return anyhow::Ok(());
            }
            let mut board = BOARD_ACCESS.lock().unwrap();
            board.set_wifi(&wifi_config.unwrap())?;
            let mut response = request.into_status_response(202)?;
            response.write("saved".as_bytes())?;
            reboot_now.store(true, std::sync::atomic::Ordering::Relaxed);
            anyhow::Ok(())
        })
        .unwrap();
    server
}

pub fn httpd(reboot_now: Arc<AtomicBool>) -> Box<EspHttpServer<'static>> {
    let mut server = shared();

    server
        .fn_handler("/", Method::Get, move |request| {
            let mut response = request.into_ok_response()?;
            response.write(include_bytes!("config.html"))?;
            anyhow::Ok(())
        })
        .unwrap();

    server
        .fn_handler("/get_config", Method::Get, move |request| {
            let mut response = request.into_ok_response()?;
            let mut board = BOARD_ACCESS.lock().unwrap();
            match board.get_config() {
                Ok(config) => {
                    let config_json = serde_json::to_string(&config)?;
                    response.write(config_json.as_bytes())?;
                }
                Err(_) => {
                    let config_json = serde_json::to_string(&Config::default())?;
                    response.write(config_json.as_bytes())?;
                }
            }
            anyhow::Ok(())
        })
        .unwrap();

    server
        .fn_handler("/set_config", Method::Post, move |mut request| {
            let mut buf = [0_u8; 3072];
            let read = request.read(&mut buf);
            if read.is_err() {
                let error_text = read.unwrap_err().to_string();
                println!("Could not parse config {}", error_text);
                request
                    .into_status_response(500)?
                    .write(error_text.as_bytes())?;
                return anyhow::Ok(());
            }
            let actual_data = &buf[0..read.unwrap()];
            println!("Raw data {}", from_utf8(actual_data).unwrap());
            let config: Result<Config, serde_json::Error> = serde_json::from_slice(actual_data);
            if config.is_err() {
                let error_text = config.unwrap_err().to_string();
                println!("Could not parse config {}", error_text);
                request
                    .into_status_response(500)?
                    .write(error_text.as_bytes())?;
                return Ok(());
            }
            let mut board = BOARD_ACCESS.lock().unwrap();
            board.set_config(&config.unwrap())?;
            let mut response = request.into_status_response(202)?;
            response.write("saved".as_bytes())?;
            reboot_now.store(true, std::sync::atomic::Ordering::Relaxed);
            Ok(())
        })
        .unwrap();
    server
}

pub fn shared() -> Box<EspHttpServer<'static>> {
    let server_config = Configuration {
        stack_size: 8192,
        ..Default::default()
    };
    let mut server: Box<EspHttpServer<'static>> =
        Box::new(EspHttpServer::new(&server_config).unwrap());
    server
        .fn_handler("/version", Method::Get, |request| {
            let mut response = request.into_ok_response()?;
            let git_hash = env!("VERGEN_GIT_DESCRIBE");
            let build_time = env!("VERGEN_BUILD_TIMESTAMP");
            let version_info = VersionInfo {
                git_hash,
                build_time,
            };
            let version_info_json = serde_json::to_string(&version_info)?;
            response.write(version_info_json.as_bytes())?;
            anyhow::Ok(())
        })
        .unwrap();
    server
        .fn_handler("/bundle.js", Method::Get, |request| {
            let mut response = request.into_ok_response()?;
            response.write(include_bytes!("bundle.js"))?;
            anyhow::Ok(())
        })
        .unwrap();
    server
        .fn_handler("/favicon.ico", Method::Get, |request| {
            let mut response = request.into_ok_response()?;
            response.write(include_bytes!("favicon.ico"))?;
            anyhow::Ok(())
        })
        .unwrap();
    server
        .fn_handler("/ota", Method::Post, |mut request| {
            let ota = OtaUpdate::begin();
            if ota.is_err() {
                let error_text = ota.unwrap_err().to_string();
                request
                    .into_status_response(500)?
                    .write(error_text.as_bytes())?;
                return anyhow::Ok(());
            }
            let mut ota = ota.unwrap();
            println!("start ota");

            //having a larger buffer is not really faster, requires more stack and prevents the progress bar from working ;)
            const BUFFER_SIZE: usize = 512;
            let mut buffer: [u8; BUFFER_SIZE] = [0; BUFFER_SIZE];
            let mut total_read: usize = 0;
            loop {
                let read = request.read(&mut buffer).unwrap();
                total_read += read;
                println!("received {read} bytes ota {total_read}");
                let to_write = &buffer[0..read];

                let write_result = ota.write(to_write);
                if write_result.is_err() {
                    let error_text = write_result.unwrap_err().to_string();
                    request
                        .into_status_response(500)?
                        .write(error_text.as_bytes())?;
                    return Ok(());
                }
                println!("wrote {read} bytes ota {total_read}");
                if read == 0 {
                    break;
                }
            }
            println!("finish ota");
            let partition = ota.raw_partition();
            println!("finalizing and changing boot partition to {partition:?}");

            let finalizer = ota.finalize();
            if finalizer.is_err() {
                let error_text = finalizer.err().unwrap().to_string();
                request
                    .into_status_response(500)?
                    .write(error_text.as_bytes())?;
                return Ok(());
            }
            let mut finalizer = finalizer.unwrap();

            println!("changing boot partition");
            finalizer.set_as_boot_partition().unwrap();
            finalizer.restart();
        })
        .unwrap();
    server
        .fn_handler("/boardtest", Method::Post, move |_| {
            let mut board = BOARD_ACCESS.lock().unwrap();
            board.test()?;
            anyhow::Ok(())
        })
        .unwrap();
    server
        .fn_handler("/pumptest", Method::Post, |mut request| {
            let mut buf = [0_u8; 3072];
            let read = request.read(&mut buf);
            if read.is_err() {
                let error_text = read.unwrap_err().to_string();
                println!("Could not parse testrequest {}", error_text);
                request
                    .into_status_response(500)?
                    .write(error_text.as_bytes())?;
                return anyhow::Ok(());
            }
            let actual_data = &buf[0..read.unwrap()];
            println!("Raw data {}", from_utf8(actual_data).unwrap());
            let pump_test: Result<TestPump, serde_json::Error> =
                serde_json::from_slice(actual_data);
            if pump_test.is_err() {
                let error_text = pump_test.unwrap_err().to_string();
                println!("Could not parse TestPump {}", error_text);
                request
                    .into_status_response(500)?
                    .write(error_text.as_bytes())?;
                return Ok(());
            }
            let mut board = BOARD_ACCESS.lock().unwrap();
            board.test_pump(pump_test.unwrap().pump)?;
            anyhow::Ok(())
        })
        .unwrap();
    server
        .fn_handler("/flashbattery", Method::Post, move |mut request| {
            let mut board = BOARD_ACCESS.lock().unwrap();
            let mut buffer: [u8; 128] = [0; 128];
            let mut line_buffer: VecDeque<u8> = VecDeque::new();

            let is_dry_run = !request.uri().ends_with("?flash=true");
            let mut total_read: usize = 0;

            let mut toggle = true;
            let delay = Delay::new(1);
            loop {
                delay.delay_us(2);
                let read = request.read(&mut buffer).unwrap();
                total_read += read;
                if read == 0 {
                    if line_buffer.len() > 0 {
                        println!("No further body but no endline");
                        let mut line = std::string::String::new();
                        line_buffer.read_to_string(&mut line).unwrap();
                        let msg = format!("Finished reading, but there is still some leftover in buffer and no full line {line}<br>");
                        println!("{}", msg);
                        let mut response = request.into_status_response(400_u16).unwrap();          
                        response.write(msg.as_bytes()).unwrap();
                        response.flush().unwrap();
                        return anyhow::Ok(())
                    }
                    break;
                }
                let to_write = &buffer[0..read];
                
                line_buffer.write_all(to_write).unwrap();
                board.general_fault(toggle);
                toggle = !toggle;
                
                loop {
                    let has_line = line_buffer.contains(&b'\n');
                    if !has_line {
                        break;
                    }
                    let mut line = std::string::String::new();
                    line_buffer.read_line(&mut line)?;
                    let line2 = &line[0..line.len()-1];
                    println!("Processing dry:{} line {}", is_dry_run, line2);
                    let validate = board.flash_bq34_z100(&line2, is_dry_run);
                    delay.delay_us(2);
                    if validate.is_err() {
                        let mut response = request.into_status_response(400_u16).unwrap();          
                        let err = validate.unwrap_err();
                        let err_str = err.to_string();
                        let err_msg = err_str.as_bytes();
                        println!("Error writing {}", err_str);
                        response
                            .write(err_msg)
                            .unwrap();
                        return anyhow::Ok(())
                    }
                }
            }
            let mut response = request.into_status_response(200_u16).unwrap();          
            let msg = format!("Finished writing {total_read} bytes<br>");
            response.write(msg.as_bytes()).unwrap();
            board.general_fault(false);
            anyhow::Ok(())
        })
        .unwrap();
    server
}