use eframe::egui;
use robot36_encoder::{Encoder, Robot36Image};
use std::path::PathBuf;
use std::time::Instant;
use std::thread;
use std::sync::mpsc::{self, Receiver, Sender};
use hound::{WavSpec, WavWriter, SampleFormat};
use image::{Rgba, RgbaImage};
use rusttype::{Font, Scale, point};

// Simple 8x8 bitmap font implementation
mod builtin_font {
    use image::{Rgba, RgbaImage};
    // Each character is 8 bytes (8x8 pixels)
    const FONT_DATA: &[u8] = include_bytes!("../font8x8_basic.bin");

    pub fn draw_text(
        image: &mut RgbaImage,
        x: u32,
        y: u32,
        text: &str,
        color: Rgba<u8>,
        scale: u32, // scale factor for font size
    ) {
        let char_width = 8u32;
        let char_height = 8u32;

        for (i, c) in text.chars().enumerate() {
            let char_index = c as usize;
            if char_index >= 128 {
                continue;
            }

            let font_data = &FONT_DATA[char_index * char_width as usize..(char_index + 1) * char_width as usize];

            for row in 0..char_height {
                for col in 0..char_width {
                    if font_data[row as usize] & (1 << (7 - col)) != 0 {
                        let px = x + (i as u32 * char_width * scale) + col * scale;
                        let py = y + row * scale;
                        for dx in 0..scale {
                            for dy in 0..scale {
                                let fx = px + dx;
                                let fy = py + dy;
                                if fx < image.width() && fy < image.height() {
                                    image.put_pixel(fx, fy, color);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

#[derive(Debug, Clone)]
enum EncodingState {
    Idle,
    Loading,
    Encoding { start_time: Instant },
    Completed { output_path: PathBuf },
    Error(String),
}

#[derive(Debug, Clone)]
enum ProgressMessage {
    Progress(f32),
    Completed(PathBuf),
    Error(String),
}

struct Robot36EncoderApp {
    input_file: Option<PathBuf>,
    output_file: Option<PathBuf>,
    encoding_state: EncodingState,
    progress: f32,
    sample_rate: u32,
    callsign: String,
    encoding_thread: Option<thread::JoinHandle<()>>,
    progress_receiver: Option<Receiver<ProgressMessage>>,
    show_success_dialog: bool,
    error_message: Option<String>,
    settings_open: bool,
}

impl Default for Robot36EncoderApp {
    fn default() -> Self {
        Self {
            input_file: None,
            output_file: None,
            encoding_state: EncodingState::Idle,
            progress: 0.0,
            sample_rate: 48000,
            callsign: String::new(),
            encoding_thread: None,
            progress_receiver: None,
            show_success_dialog: false,
            error_message: None,
            settings_open: false,
        }
    }
}

impl Robot36EncoderApp {
    fn new(_cc: &eframe::CreationContext<'_>) -> Self {
        Self::default()
    }
    
    fn select_input_file(&mut self) {
        if let Some(path) = rfd::FileDialog::new()
            .add_filter("Image Files", &["png", "jpg", "jpeg", "bmp", "gif", "tiff", "webp"])
            .set_title("Select Input Image")
            .pick_file()
        {
            self.input_file = Some(path.clone());
            let mut output_path = path.clone();
            output_path.set_extension("wav");
            self.output_file = Some(output_path);
            self.encoding_state = EncodingState::Idle;
            self.progress = 0.0;
            self.error_message = None;
        }
    }
    
    fn select_output_file(&mut self) {
        if let Some(path) = rfd::FileDialog::new()
            .add_filter("Audio Files", &["wav"])
            .set_title("Save Audio Output")
            .set_file_name(
                self.input_file.as_ref()
                    .and_then(|p| p.file_stem())
                    .map(|s| format!("{}.wav", s.to_string_lossy()))
                    .unwrap_or_else(|| "output.wav".to_string())
            )
            .save_file()
        {
            self.output_file = Some(path);
        }
    }
    
    fn start_encoding(&mut self) {
        if let (Some(input_path), Some(output_path)) = (&self.input_file, &self.output_file) {
            self.encoding_state = EncodingState::Loading;
            self.progress = 0.0;
            self.error_message = None;
            
            let (tx, rx) = mpsc::channel();
            self.progress_receiver = Some(rx);
            
            let input_path = input_path.clone();
            let output_path = output_path.clone();
            let sample_rate = self.sample_rate;
            let callsign = self.callsign.clone();
            
            self.encoding_thread = Some(thread::spawn(move || {
                Self::encode_image_thread(input_path, output_path, sample_rate, callsign, tx);
            }));
        }
    }
    
    fn encode_image_thread(
        input_path: PathBuf,
        output_path: PathBuf,
        sample_rate: u32,
        callsign: String,
        tx: Sender<ProgressMessage>,
    ) {
        let result = Self::encode_image_impl(input_path, output_path.clone(), sample_rate, callsign, &tx);
        
        match result {
            Ok(()) => {
                let _ = tx.send(ProgressMessage::Completed(output_path));
            }
            Err(e) => {
                let _ = tx.send(ProgressMessage::Error(e.to_string()));
            }
        }
    }
    
    fn draw_callsign_with_rusttype(image: &mut RgbaImage, text: &str) {
        // Path to a common system font found on this system
        let font_data = std::fs::read("/usr/share/fonts/TTF/VictorMonoNerdFont-Thin.ttf")
            .expect("Failed to load system font");
        let font = Font::try_from_vec(font_data).expect("Error constructing Font");
        let scale = Scale::uniform(32.0); // Adjust size as needed
        let start = point(5.0, 32.0); // x, y baseline
        let color = Rgba([0u8, 0u8, 0u8, 255u8]);

        // Draw each glyph
        let v_metrics = font.v_metrics(scale);
        let glyphs: Vec<_> = font.layout(text, scale, start).collect();
        for glyph in glyphs {
            if let Some(bb) = glyph.pixel_bounding_box() {
                glyph.draw(|gx, gy, gv| {
                    let x = gx as i32 + bb.min.x;
                    let y = gy as i32 + bb.min.y;
                    if x >= 0 && y >= 0 && (x as u32) < image.width() && (y as u32) < image.height() {
                        let alpha = (gv * 255.0) as u8;
                        let pixel = image.get_pixel_mut(x as u32, y as u32);
                        *pixel = Rgba([
                            color[0],
                            color[1],
                            color[2],
                            alpha,
                        ]);
                    }
                });
            }
        }
    }
    
    fn encode_image_impl(
        input_path: PathBuf,
        output_path: PathBuf,
        sample_rate: u32,
        callsign: String,
        tx: &Sender<ProgressMessage>,
    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        let _ = tx.send(ProgressMessage::Progress(0.1));
        
        // Load image and convert to RGBA
        let mut image = image::open(&input_path)?.to_rgba8();
        let _ = tx.send(ProgressMessage::Progress(0.2));
        
        // Add callsign overlay if provided
        if !callsign.is_empty() {
            Self::draw_callsign_with_rusttype(&mut image, &callsign);
        }
        
        // Calculate target size while maintaining aspect ratio
        let target_width = 320;
        let target_height = 240;
        
        let (width, height) = image.dimensions();
        let ratio = width as f32 / height as f32;
        let (new_width, new_height) = if ratio > (target_width as f32 / target_height as f32) {
            (target_width, (target_width as f32 / ratio) as u32)
        } else {
            ((target_height as f32 * ratio) as u32, target_height)
        };
        
        // Resize with padding to maintain 320x240
        let mut resized_image = image::DynamicImage::new_rgb8(target_width, target_height);
        let temp_image = image::DynamicImage::ImageRgba8(image)
            .resize_exact(new_width, new_height, image::imageops::FilterType::Lanczos3);
        
        // Center the image
        let x_offset = (target_width - new_width) / 2;
        let y_offset = (target_height - new_height) / 2;
        
        image::imageops::overlay(&mut resized_image, &temp_image, x_offset as i64, y_offset as i64);
        
        let _ = tx.send(ProgressMessage::Progress(0.3));
        
        // Convert to Robot36Image (original encoding logic untouched)
        let robot36_image = Robot36Image::from_image(resized_image)?;
        let _ = tx.send(ProgressMessage::Progress(0.4));
        
        let encoder = Encoder::new(robot36_image, sample_rate as u64);
        let _ = tx.send(ProgressMessage::Progress(0.5));
        
        let samples: Vec<i16> = encoder.encode().collect();
        let _ = tx.send(ProgressMessage::Progress(0.8));
        
        let spec = WavSpec {
            channels: 1,
            sample_rate,
            bits_per_sample: 16,
            sample_format: SampleFormat::Int,
        };
        
        let mut writer = WavWriter::create(&output_path, spec)?;
        
        let total_samples = samples.len();
        for (i, sample) in samples.into_iter().enumerate() {
            writer.write_sample(sample)?;
            
            if i % 10000 == 0 {
                let progress = 0.8 + (i as f32 / total_samples as f32) * 0.2;
                let _ = tx.send(ProgressMessage::Progress(progress));
            }
        }
        
        writer.finalize()?;
        let _ = tx.send(ProgressMessage::Progress(1.0));
        
        Ok(())
    }
    
    fn stop_encoding(&mut self) {
        self.encoding_state = EncodingState::Idle;
        self.progress = 0.0;
        
        if let Some(handle) = self.encoding_thread.take() {
            handle.join().ok();
        }
        
        self.progress_receiver = None;
    }
    
    fn update_progress(&mut self) {
        let mut should_clear_receiver = false;
        let mut completed_path = None;
        
        if let Some(receiver) = &self.progress_receiver {
            while let Ok(message) = receiver.try_recv() {
                match message {
                    ProgressMessage::Progress(progress) => {
                        self.progress = progress;
                        if progress > 0.4 && matches!(self.encoding_state, EncodingState::Loading) {
                            self.encoding_state = EncodingState::Encoding { 
                                start_time: Instant::now() 
                            };
                        }
                    }
                    ProgressMessage::Completed(output_path) => {
                        completed_path = Some(output_path);
                        self.encoding_state = EncodingState::Completed { output_path: completed_path.clone().unwrap() };
                        self.progress = 1.0;
                        self.show_success_dialog = true;
                        should_clear_receiver = true;
                    }
                    ProgressMessage::Error(error) => {
                        self.encoding_state = EncodingState::Error(error.clone());
                        self.error_message = Some(error);
                        self.progress = 0.0;
                        should_clear_receiver = true;
                    }
                }
            }
        }
        
        if should_clear_receiver {
            self.progress_receiver = None;
            if let Some(handle) = self.encoding_thread.take() {
                handle.join().ok();
            }
        }
    }
    
    fn get_remaining_time(&self) -> f32 {
        match &self.encoding_state {
            EncodingState::Encoding { start_time } => {
                let _elapsed = start_time.elapsed().as_secs_f32();
                let estimated_total = 45.0;
                let progress_based_remaining = (1.0 - self.progress) * estimated_total;
                progress_based_remaining.max(0.0)
            }
            _ => 45.0,
        }
    }
    
    fn is_encoding(&self) -> bool {
        matches!(self.encoding_state, EncodingState::Loading | EncodingState::Encoding { .. })
    }
    
    fn can_start_encoding(&self) -> bool {
        self.input_file.is_some() && 
        self.output_file.is_some() && 
        !self.is_encoding()
    }
    
    fn open_with_vlc(&self, path: &PathBuf) {
        let path_str = path.to_string_lossy().to_string();
        
        #[cfg(target_os = "windows")]
        {
            let _ = std::process::Command::new("cmd")
                .args(["/C", "start", "vlc", &path_str])
                .spawn();
        }
        
        #[cfg(target_os = "macos")]
        {
            let _ = std::process::Command::new("open")
                .args(["-a", "VLC", &path_str])
                .spawn();
        }
        
        #[cfg(target_os = "linux")]
        {
            let _ = std::process::Command::new("vlc")
                .arg(&path_str)
                .spawn();
        }
    }
}

impl eframe::App for Robot36EncoderApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        self.update_progress();
        
        ctx.set_visuals(egui::Visuals {
            dark_mode: true,
            override_text_color: Some(egui::Color32::WHITE),
            window_fill: egui::Color32::from_rgb(32, 32, 32),
            panel_fill: egui::Color32::from_rgb(40, 40, 40),
            ..egui::Visuals::dark()
        });
        
        if self.show_success_dialog {
            let output_path = if let EncodingState::Completed { output_path } = &self.encoding_state {
                output_path.clone()
            } else {
                PathBuf::new()
            };
            
            egui::Window::new("🎉 Encoding Complete!")
                .collapsible(false)
                .resizable(false)
                .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
                .show(ctx, |ui| {
                    ui.add_space(10.0);
                    
                    ui.vertical_centered(|ui| {
                        ui.heading("✅ Success!");
                        ui.add_space(5.0);
                        ui.label("Your image has been encoded to Robot36 audio format");
                    });
                    
                    ui.add_space(10.0);
                    ui.separator();
                    ui.add_space(10.0);
                    
                    ui.label(format!("📁 Saved to: {}", output_path.display()));
                    
                    ui.add_space(15.0);
                    
                    ui.horizontal(|ui| {
                        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                            if ui.button("Close").clicked() {
                                self.show_success_dialog = false;
                            }
                            
                            if ui.button("🎵 Open with VLC").clicked() {
                                self.open_with_vlc(&output_path);
                                self.show_success_dialog = false;
                            }
                            
                            if ui.button("📂 Open Folder").clicked() {
                                if let Some(parent) = output_path.parent() {
                                    #[cfg(target_os = "windows")]
                                    {
                                        let _ = std::process::Command::new("explorer")
                                            .arg(parent)
                                            .spawn();
                                    }
                                    
                                    #[cfg(target_os = "macos")]
                                    {
                                        let _ = std::process::Command::new("open")
                                            .arg(parent)
                                            .spawn();
                                    }
                                    
                                    #[cfg(target_os = "linux")]
                                    {
                                        let _ = std::process::Command::new("xdg-open")
                                            .arg(parent)
                                            .spawn();
                                    }
                                }
                                self.show_success_dialog = false;
                            }
                        });
                    });
                });
        }
        
        egui::CentralPanel::default().show(ctx, |ui| {
            ui.horizontal(|ui| {
                ui.label("📡 Callsign:");
                ui.add(
                    egui::TextEdit::singleline(&mut self.callsign)
                        .hint_text("Enter your callsign (optional)")
                        .desired_width(150.0)
                );
                
                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                    if ui.button("⚙️ Settings").clicked() {
                        self.settings_open = !self.settings_open;
                    }
                });
            });
            
            ui.add_space(10.0);
            ui.separator();
            ui.add_space(20.0);
            
            ui.vertical_centered(|ui| {
                ui.heading("🤖 Robot36 SSTV Encoder");
                ui.label("Convert images to SSTV audio format");
            });
            
            ui.add_space(30.0);
            
            ui.vertical_centered(|ui| {
                egui::Frame::none()
                    .fill(egui::Color32::from_rgb(48, 48, 48))
                    .rounding(egui::Rounding::same(12.0))
                    .inner_margin(egui::Margin::same(20.0))
                    .show(ui, |ui| {
                        ui.vertical_centered(|ui| {
                            ui.heading("📁 Select Files");
                            ui.add_space(10.0);
                            
                            if ui.add_sized([300.0, 40.0], egui::Button::new("📷 Choose Image")).clicked() {
                                self.select_input_file();
                            }
                            
                            if let Some(file_path) = &self.input_file {
                                ui.add_space(5.0);
                                ui.label(format!("📄 {}", file_path.file_name().unwrap_or_default().to_string_lossy()));
                            }
                            
                            ui.add_space(10.0);
                            
                            if ui.add_sized([300.0, 40.0], egui::Button::new("💾 Save Audio As")).clicked() {
                                self.select_output_file();
                            }
                            
                            if let Some(file_path) = &self.output_file {
                                ui.add_space(5.0);
                                ui.label(format!("🔊 {}", file_path.file_name().unwrap_or_default().to_string_lossy()));
                            }
                        });
                    });
                
                ui.add_space(30.0);
                
                if self.is_encoding() || matches!(self.encoding_state, EncodingState::Completed { .. }) {
                    egui::Frame::none()
                        .fill(egui::Color32::from_rgb(48, 48, 48))
                        .rounding(egui::Rounding::same(12.0))
                        .inner_margin(egui::Margin::same(20.0))
                        .show(ui, |ui| {
                            ui.vertical_centered(|ui| {
                                ui.heading("⚡ Encoding Progress");
                                ui.add_space(15.0);
                                
                                let progress_bar = egui::ProgressBar::new(self.progress)
                                    .text(format!("{:.1}%", self.progress * 100.0))
                                    .desired_width(300.0)
                                    .desired_height(20.0);
                                ui.add(progress_bar);
                                
                                ui.add_space(10.0);
                                
                                let status_text = match &self.encoding_state {
                                    EncodingState::Loading => "🔄 Loading image...",
                                    EncodingState::Encoding { .. } => "🎵 Encoding to audio...",
                                    EncodingState::Completed { .. } => "✅ Encoding complete!",
                                    _ => "",
                                };
                                ui.label(status_text);
                                
                                if self.is_encoding() {
                                    let remaining = self.get_remaining_time();
                                    ui.label(format!("⏱️ {:.1}s remaining", remaining));
                                }
                            });
                        });
                    
                    ui.add_space(20.0);
                }
                
                ui.horizontal(|ui| {
                    if self.is_encoding() {
                        if ui.add_sized([150.0, 50.0], egui::Button::new("⏹️ Stop")).clicked() {
                            self.stop_encoding();
                        }
                    } else {
                        let start_button = egui::Button::new("🚀 Start Encoding")
                            .fill(egui::Color32::from_rgb(0, 120, 215));
                        
                        if ui.add_sized([200.0, 50.0], start_button).clicked() && self.can_start_encoding() {
                            self.start_encoding();
                        }
                    }
                });
                
                ui.add_space(20.0);
                
                match &self.encoding_state {
                    EncodingState::Idle => {
                        if !self.can_start_encoding() {
                            ui.colored_label(egui::Color32::GRAY, "ℹ️ Please select input and output files");
                        }
                    }
                    EncodingState::Completed { output_path } => {
                        ui.colored_label(egui::Color32::GREEN, 
                            format!("✅ Audio saved to: {}", output_path.file_name().unwrap_or_default().to_string_lossy()));
                        
                        ui.add_space(10.0);
                        ui.horizontal(|ui| {
                            if ui.button("🎵 Open with VLC").clicked() {
                                self.open_with_vlc(output_path);
                            }
                            
                            if ui.button("📂 Open Folder").clicked() {
                                if let Some(parent) = output_path.parent() {
                                    #[cfg(target_os = "windows")]
                                    {
                                        let _ = std::process::Command::new("explorer")
                                            .arg(parent)
                                            .spawn();
                                    }
                                    
                                    #[cfg(target_os = "macos")]
                                    {
                                        let _ = std::process::Command::new("open")
                                            .arg(parent)
                                            .spawn();
                                    }
                                    
                                    #[cfg(target_os = "linux")]
                                    {
                                        let _ = std::process::Command::new("xdg-open")
                                            .arg(parent)
                                            .spawn();
                                    }
                                }
                            }
                        });
                    }
                    EncodingState::Error(msg) => {
                        ui.colored_label(egui::Color32::RED, format!("❌ Error: {}", msg));
                    }
                    _ => {}
                }
            });
        });
        
        if self.settings_open {
            egui::Window::new("⚙️ Settings")
                .collapsible(false)
                .resizable(false)
                .anchor(egui::Align2::RIGHT_TOP, [-10.0, 60.0])
                .show(ctx, |ui| {
                    ui.label("🎵 Audio Settings");
                    ui.separator();
                    
                    ui.horizontal(|ui| {
                        ui.label("Sample Rate:");
                        ui.add(
                            egui::Slider::new(&mut self.sample_rate, 8000..=96000)
                                .suffix(" Hz")
                                .logarithmic(true)
                                .clamp_to_range(true)
                        );
                    });
                    
                    ui.add_space(10.0);
                    
                    ui.label("ℹ️ Higher sample rates produce better quality audio but larger files.");
                    
                    ui.add_space(10.0);
                    
                    if ui.button("Close").clicked() {
                        self.settings_open = false;
                    }
                });
        }
        
        if self.is_encoding() {
            ctx.request_repaint();
        }
    }
}

fn main() -> eframe::Result<()> {
    env_logger::init();
    
    let options = eframe::NativeOptions {
        viewport: egui::ViewportBuilder::default()
            .with_inner_size([700.0, 600.0])
            .with_min_inner_size([600.0, 500.0])
            .with_title("Robot36 SSTV Encoder"),
        ..Default::default()
    };
    
    eframe::run_native(
        "Robot36 SSTV Encoder",
        options,
        Box::new(|cc| Ok(Box::new(Robot36EncoderApp::new(cc)))),
    )
}