pub struct WorkerArgs {
    region: Rect<u32>,
    handler: Box<dyn FnMut(&RgbImage) + Send + 'static>,
}

pub struct VideoStreamHandler {
    pub args: WorkerArgs
}

impl GraphicsCaptureApiHandler for VideoStreamHandler {
    type Flags = WorkerArgs;
    type Error = anyhow::Error;

    fn new(flags: Self::Flags) -> std::result::Result<Self, Self::Error> {
        println!("create stream handler");
        Ok(Self {
            args: flags
        })
    }

    fn on_frame_arrived(&mut self, frame: &mut Frame, _capture_control: InternalCaptureControl) -> std::result::Result<(), Self::Error> {
        println!("on frame arrived");
        let width = self.args.region.width;
        let height = self.args.region.height;
        let left = self.args.region.left;
        let top = self.args.region.top;

        let image = RgbImage::from_fn(width, height, |x, y| {
            let mut cropped_image = frame.buffer_crop(
                left,
                top,
                width,
                height
            ).unwrap();

            let index = (y * width + x) as usize;
            let buffer = cropped_image.as_raw_buffer();
            let r = buffer[index * 4];
            let g = buffer[index * 4 + 1];
            let b = buffer[index * 4 + 2];
            Rgb([r, g, b])
        });
        self.args.handler.call_mut((&image,));

        Ok(())
    }
}

#![cfg_attr(
    all(not(debug_assertions), target_os = "windows"),
    windows_subsystem = "windows"
)]

mod screen_capture;

use tauri::Builder;

fn main() {
    Builder::default()
        .invoke_handler(tauri::generate_handler![
            screen_capture::start_capture, 
            screen_capture::stop_capture
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

use std::{
    io::{self, Write},
    time::Instant,
};

use windows_capture::{
    capture::GraphicsCaptureApiHandler,
    encoder::{VideoEncoder, VideoEncoderQuality, VideoEncoderType},
    frame::Frame,
    graphics_capture_api::InternalCaptureControl,
    monitor::Monitor,
    settings::{ColorFormat, CursorCaptureSettings, DrawBorderSettings, Settings},
};

// This struct will be used to handle the capture events.
struct Capture {
    // The video encoder that will be used to encode the frames.
    encoder: Option<VideoEncoder>,
    // To measure the time the capture has been running
    start: Instant,
}

impl GraphicsCaptureApiHandler for Capture {
    // The type of flags used to get the values from the settings.
    type Flags = String;

    // The type of error that can occur during capture, the error will be returned from `CaptureControl` and `start` functions.
    type Error = Box<dyn std::error::Error + Send + Sync>;

    // Function that will be called to create the struct. The flags can be passed from settings.
    fn new(message: Self::Flags) -> Result<Self, Self::Error> {
        println!("Got The Flag: {message}");

        let encoder = VideoEncoder::new(
            VideoEncoderType::Mp4,
            VideoEncoderQuality::HD1080p,
            1920,
            1080,
            "video.mp4",
        )?;

        Ok(Self {
            encoder: Some(encoder),
            start: Instant::now(),
        })
    }

    // Called every time a new frame is available.
    fn on_frame_arrived(
        &mut self,
        frame: &mut Frame,
        capture_control: InternalCaptureControl,
    ) -> Result<(), Self::Error> {
        print!(
            "\rRecording for: {} seconds",
            self.start.elapsed().as_secs()
        );
        io::stdout().flush()?;

        // Send the frame to the video encoder
        self.encoder.as_mut().unwrap().send_frame(frame)?;

        // Note: The frame has other uses too for example you can save a single for to a file like this:
        // frame.save_as_image("frame.png", ImageFormat::Png)?;
        // Or get the raw data like this so you have full control:
        // let data = frame.buffer()?;

        // Stop the capture after 6 seconds
        if self.start.elapsed().as_secs() >= 6 {
            // Finish the encoder and save the video.
            self.encoder.take().unwrap().finish()?;

            capture_control.stop();

            // Because there wasn't any new lines in previous prints
            println!();
        }

        Ok(())
    }

    // Optional handler called when the capture item (usually a window) closes.
    fn on_closed(&mut self) -> Result<(), Self::Error> {
        println!("Capture Session Closed");

        Ok(())
    }
}

fn main() {
    // Gets The Foreground Window, Checkout The Docs For Other Capture Items
    let primary_monitor = Monitor::primary().expect("There is no primary monitor");

    let settings = Settings::new(
        // Item To Captue
        primary_monitor,
        // Capture Cursor Settings
        CursorCaptureSettings::Default,
        // Draw Borders Settings
        DrawBorderSettings::Default,
        // The desired color format for the captured frame.
        ColorFormat::Rgba8,
        // Additional flags for the capture settings that will be passed to user defined `new` function.
        "Yea This Works".to_string(),
    )
    .unwrap();

    // Starts the capture and takes control of the current thread.
    // The errors from handler trait will end up here
    Capture::start(settings).expect("Screen Capture Failed");
}

use std::thread::sleep;
use std::time::Duration;

use windows_capture::window::Window;
use windows_capture::{
    capture::GraphicsCaptureApiHandler,
    frame::Frame,
    graphics_capture_api::InternalCaptureControl,
    settings::{ColorFormat, CursorCaptureSettings, DrawBorderSettings, Settings},
};

struct Capture {}

impl GraphicsCaptureApiHandler for Capture {
    type Flags = String;

    type Error = Box<dyn std::error::Error + Send + Sync>;

    fn new(message: Self::Flags) -> Result<Self, Self::Error> {
        Ok(Self {})
    }

    fn on_frame_arrived(
        &mut self,
        frame: &mut Frame,
        capture_control: InternalCaptureControl,
    ) -> Result<(), Self::Error> {
        println!("Frame Arrived");
        Ok(())
    }

    fn on_closed(&mut self) -> Result<(), Self::Error> {
        println!("Capture Session Closed");
        Ok(())
    }
}

fn main() {
    let window = Window::from_raw_hwnd(0x000B14CA);

    let settings = Settings::new(
        window,
        CursorCaptureSettings::Default,
        DrawBorderSettings::Default,
        ColorFormat::Rgba8,
        "Yea This Works".to_string(),
    )
    .unwrap();

    std::thread::spawn(move || {
        Capture::start(settings).unwrap();
        println!("capture closed");
    });
    // Capture::start(settings).expect("Screen Capture Failed");

    loop {
        sleep(Duration::from_secs(1));
    }
}

let settings = Settings::new(
    // Item To Captue
    primary_monitor,
    // Capture Cursor Settings
    CursorCaptureSettings::WithCursor,
    // Draw Borders Settings
    DrawBorderSettings::WithoutBorder,
    // The desired color format for the captured frame.
    ColorFormat::Rgba8,
    // Additional flags for the capture settings that will be passed to user defined `new` function.
    "Yea This Works".to_string(),
)
.unwrap();

use windows::Win32::Foundation::HWND;
use windows_capture::{
    capture::WindowsCaptureHandler,
    frame::{Frame, ImageFormat},
    graphics_capture_api::InternalCaptureControl,
    settings::{ColorFormat, Settings},
    window::Window,
};

struct Capture;

impl WindowsCaptureHandler for Capture {
    type Flags = String;

    type Error = Box<dyn std::error::Error + Send + Sync>;

    fn new(message: Self::Flags) -> Result<Self, Self::Error> {
        println!("Got The Flag: {message}");

        Ok(Self {})
    }

    fn on_frame_arrived(
        &mut self,
        frame: &mut Frame,
        capture_control: InternalCaptureControl,
    ) -> Result<(), Self::Error> {
        println!("New Frame Arrived");

        frame.save_as_image("image3.png", ImageFormat::Png)?;

        capture_control.stop();

        Ok(())
    }

    fn on_closed(&mut self) -> Result<(), Self::Error> {
        println!("Capture Session Closed");

        Ok(())
    }
}

fn main() {
    let my_window = Window::from_raw_hwnd(HWND(0x000A0B8E));

    let settings = Settings::new(
        my_window,
        Some(true),
        None,
        ColorFormat::Rgba8,
        "It Works".to_string(),
    )
    .unwrap();

    Capture::start(settings).expect("Screen Capture Failed");
}