use avm_analyzer_common::{AvmStreamInfo, DecodeProgress, DecodeState, ProgressResponse, StartDecodeResponse};
use egui::DroppedFile;

use log::{info, warn};

use rand::distributions::Alphanumeric;
use rand::Rng;
use rfd::AsyncFileDialog;
use std::collections::HashMap;
use std::io::{self, Cursor, Write};
use std::sync::{Arc, Mutex};
use wasm_bindgen_futures::spawn_local;
use web_time::Instant;

use crate::stream::{stream_name_from_file_name, Stream};

use super::HttpStreamManager;
pub const HTTP_POLL_PERIOD_SECONDS: f32 = 1.0;
pub const MAX_RETRIES: i32 = 5;

#[derive(Clone)]
pub struct PendingServerDecode {
    pub stream_info: AvmStreamInfo,
    pub state: DecodeState,
    pub start_time: Instant,
    pub started_loading_first_frame: bool,
    // For retries:
    pub bytes: Arc<[u8]>,
    pub retry_count: i32,
}

impl PendingServerDecode {
    fn new(name: &str, state: DecodeState, bytes: Arc<[u8]>, retries_left: i32) -> Self {
        let stream_info = AvmStreamInfo {
            stream_name: name.into(),
            proto_path_template: "".into(),
            num_frames: 0,
            thumbnail_png: None,
        };
        Self {
            stream_info,
            state,
            start_time: Instant::now(),
            started_loading_first_frame: false,
            bytes,
            retry_count: retries_left,
        }
    }
}

pub struct ServerDecodeManager {
    pub pending_decodes: Arc<Mutex<HashMap<String, PendingServerDecode>>>,
    last_check_request: Instant,
}

impl ServerDecodeManager {
    pub fn new() -> Self {
        Self {
            pending_decodes: Arc::new(Mutex::new(HashMap::new())),
            last_check_request: Instant::now(),
        }
    }
    pub fn prompt_stream(&self) {
        let task = AsyncFileDialog::new()
            .add_filter("AVM Stream", &["bin", "ivf", "obu"])
            .pick_file();
        let pending_decodes = self.pending_decodes.clone();
        spawn_local(async move {
            let file = task.await;
            if let Some(file) = file {
                let bytes = file.read().await;
                upload(file.file_name().as_str(), bytes.into(), pending_decodes, MAX_RETRIES);
            }
        });
    }

    pub fn handle_dropped_file(&self, file: DroppedFile) {
        let pending_decodes = self.pending_decodes.clone();
        if let Some(bytes) = file.bytes {
            spawn_local(async move {
                upload(file.name.as_str(), bytes, pending_decodes, MAX_RETRIES);
            });
        }
    }

    pub fn check_newly_confirmed_uploads(&mut self, stream: &mut Option<Stream>, streams_url: &str) {
        let mut pending_decodes = self.pending_decodes.lock().unwrap();
        for (_name, pending_decode) in pending_decodes.iter_mut() {
            if let DecodeState::UploadComplete = pending_decode.state {
                *stream = Some(Stream::from_http(pending_decode.stream_info.clone(), true, 0, streams_url).unwrap());
                pending_decode.state = DecodeState::Pending(DecodeProgress {
                    decoded_frames: 0,
                    total_frames: pending_decode.stream_info.num_frames,
                });
            }
        }
    }
    fn check_for_retries(&mut self) {
        let mut retries = Vec::new();
        {
            let mut pending_decodes = self.pending_decodes.lock().unwrap();
            for (_name, pending_decode) in pending_decodes.iter_mut() {
                if matches!(pending_decode.state, DecodeState::Failed) {
                    retries.push(pending_decode.clone());
                }
            }
        }
        for retry in retries {
            if retry.retry_count > 0 {
                warn!("Retrying stream: {}. Retries remaining: {}", retry.stream_info.stream_name, retry.retry_count - 1);
                upload(
                    &retry.stream_info.stream_name,
                    retry.bytes,
                    self.pending_decodes.clone(),
                    retry.retry_count - 1
                );
            }
            else {
                warn!("Stream: {} failed after {} retries.", retry.stream_info.stream_name, MAX_RETRIES);
            }
        }
    }

    pub fn check_progress(&mut self, stream: &mut Option<Stream>, http_manager: &mut HttpStreamManager, streams_url: &str) {
        self.check_newly_confirmed_uploads(stream, streams_url);
        self.check_for_retries();
        let now = Instant::now();
        let elapsed = now - self.last_check_request;
        if elapsed.as_secs_f32() < HTTP_POLL_PERIOD_SECONDS {
            return;
        }
        self.last_check_request = now;
        let mut pending_decodes = self.pending_decodes.lock().unwrap();
        for (_name, pending_decode) in pending_decodes.iter() {
            if let DecodeState::Pending(_) = &pending_decode.state {
                let request = ehttp::Request::get(format!(
                    "/progress?stream_name={}",
                    pending_decode.stream_info.stream_name
                ));
                let inner_pending_decodes = self.pending_decodes.clone();
                ehttp::fetch(request, move |response| {
                    if let Ok(response) = response {
                        if let Some(json) = response.text() {
                            if let Ok(response) = serde_json::from_str::<ProgressResponse>(json) {
                                info!("Progress: {response:?}");
                                let mut pending_decodes = inner_pending_decodes.lock().unwrap();
                                if let Some(pending_decode) = pending_decodes.get_mut(&response.stream_name) {
                                    pending_decode.state = response.state;
                                } else {
                                    warn!(
                                        "Received decode progress update for unknown stream: {}.",
                                        response.stream_name
                                    );
                                }
                            }
                        }
                    }
                });
            }
        }
        if let Some(stream) = stream {
            // TODO(comc): Move this logic elsewhere.
            http_manager.update_pending_decodes(&pending_decodes);
            stream.update_pending_decodes(&mut pending_decodes);
        }
    }
}

const MULTIPART_FORM_BOUNDARY_PREFIX: &str = "--------";
const MULTIPART_FORM_BOUNDARY_LEN: usize = 16;

fn random_boundary() -> String {
    let alphanum: String = rand::thread_rng()
        .sample_iter(Alphanumeric)
        .take(MULTIPART_FORM_BOUNDARY_LEN)
        .map(char::from)
        .collect();
    format!("{MULTIPART_FORM_BOUNDARY_PREFIX}{alphanum}")
}

fn create_upload_request(file_name: &str, bytes: Arc<[u8]>) -> Result<ehttp::Request, io::Error> {
    let stream_name = stream_name_from_file_name(file_name);
    let mut request_body = Vec::new();
    let mut cursor = Cursor::new(&mut request_body);
    let boundary = random_boundary();
    write!(cursor, "--{}\r\n", boundary)?;
    write!(
        cursor,
        "Content-Disposition: form-data; name=\"{stream_name}\"; filename=\"{file_name}\""
    )?;
    write!(cursor, "\r\nContent-Type: {}", mime::APPLICATION_OCTET_STREAM)?;
    write!(cursor, "\r\n\r\n")?;
    cursor.write_all(&bytes)?;
    write!(cursor, "\r\n")?;
    write!(cursor, "--{}--\r\n", boundary)?;
    let content_type = format!("multipart/form-data; boundary={}", boundary);

    Ok(ehttp::Request {
        method: "POST".into(),
        url: "/upload".into(),
        body: request_body,
        headers: ehttp::headers(&[("Accept", "*/*"), ("Content-Type", &content_type)]),
    })
}

// TODO(comc): Handle duplicate stream names.
pub fn upload(file_name: &str, bytes: Arc<[u8]>, pending_decodes: Arc<Mutex<HashMap<String, PendingServerDecode>>>, retries_left: i32) {
    let stream_name = stream_name_from_file_name(file_name);
    {
        let mut pending_decodes = pending_decodes.lock().unwrap();
        if let Some(existing_decode) = pending_decodes.get(&stream_name) {
            match existing_decode.state {
                DecodeState::Pending(_) | DecodeState::UploadComplete | DecodeState::Uploading => {
                    warn!("Decode request for stream {stream_name} already pending.");
                    return;
                }
                _ => {}
            }
        }
        let new_decode = PendingServerDecode::new(&stream_name, DecodeState::Uploading, bytes.clone(), retries_left);
        pending_decodes.insert(stream_name.clone(), new_decode);
    }
    let req = create_upload_request(file_name, bytes).unwrap();
    // TODO(comc): Automatic retry on timeout.
    ehttp::fetch(req, move |response| {
        let mut decode_state = DecodeState::Failed;
        let mut updated_stream_info = None;

        if let Ok(response) = response {
            if let Some(json) = response.text() {
                info!("Got response: {}", json);
                if let Ok(response) = serde_json::from_str::<StartDecodeResponse>(json) {
                    updated_stream_info = Some(response.stream_info);
                    decode_state = DecodeState::UploadComplete;
                }
            }
        }
        let mut pending_decodes = pending_decodes.lock().unwrap();
        if let Some(pending_decode) = pending_decodes.get_mut(&stream_name) {
            pending_decode.state = decode_state;
            if let Some(updated_stream_info) = updated_stream_info {
                pending_decode.stream_info = updated_stream_info;
            }
        } else {
            warn!("Received status response for {stream_name}, but it no longer exists.");
        }
    });
}