pub mod api;
pub mod auth;
pub mod config;
pub mod metadata;
pub mod queued_item;
pub mod util;

pub const SECONDS_TO_SLEEP: u64 = 5;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut app = config::App {
        uri: icarus_envy::environment::get_icarus_base_api_url()
            .await
            .value,
        auth_uri: icarus_envy::environment::get_icarus_auth_base_api_url()
            .await
            .value,
        ..Default::default()
    };
    println!("Base URL: {:?}", app.uri);
    println!("Auth URL: {:?}", app.auth_uri);

    match auth::get_token(&app).await {
        Ok(login_result) => {
            app.token = login_result;
        }
        Err(err) => {
            eprintln!("Error: {err:?}");
            std::process::exit(-1);
        }
    };

    loop {
        println!("Token: {:?}", app.token);

        if app.token.token_expired() {
            println!("Token expired");
            app.token = match auth::get_refresh_token(&app).await {
                Ok(login_result) => login_result,
                Err(err) => {
                    eprintln!("Error: {err:?}");
                    continue;
                }
            };

            println!("Token refreshed");
            println!("Refreshed token: {:?}", app.token);
        } else {
            println!("Token did not expire");
        }

        match is_queue_empty(&app).await {
            Ok((empty, song_queue_item)) => {
                if !empty {
                    println!("Queue is not empty");
                    println!("SongQueueItem: {song_queue_item:?}");

                    let song_queue_id = song_queue_item.data[0].id;
                    let user_id = song_queue_item.data[0].user_id;

                    match some_work(&app, &song_queue_id, &user_id).await {
                        Ok((song, coverart, _metadata, queued_song, queued_coverart)) => {
                            match wipe_data_from_queues(&app, &queued_song, &queued_coverart).await
                            {
                                Ok(_) => match cleanup(&song, &coverart).await {
                                    Ok(_) => {
                                        println!("Successful cleanup");
                                    }
                                    Err(err) => {
                                        eprintln!("Error: {err:?}");
                                    }
                                },
                                Err(err) => {
                                    eprintln!("Error: {err:?}");
                                }
                            }
                        }
                        Err(err) => {
                            eprintln!("Error: {err:?}");
                        }
                    }
                } else {
                    println!("Queue is empty");
                }
            }
            Err(err) => {
                eprintln!("Error checking if queue is empty: {err:?}");
            }
        }

        println!("Sleeping");
        tokio::time::sleep(tokio::time::Duration::from_secs(SECONDS_TO_SLEEP)).await;
    }
}

async fn wipe_data_from_queues(
    app: &config::App,
    queued_song: &crate::queued_item::QueuedSong,
    queued_coverart: &crate::queued_item::QueuedCoverArt,
) -> Result<(), std::io::Error> {
    match api::wipe_data::song_queue::wipe_data(app, queued_song).await {
        Ok(response) => match response
            .json::<api::wipe_data::song_queue::response::Response>()
            .await
        {
            Ok(_resp) => {
                match api::wipe_data::coverart_queue::wipe_data(app, queued_coverart).await {
                    Ok(inner_response) => match inner_response
                        .json::<api::wipe_data::coverart_queue::response::Response>()
                        .await
                    {
                        Ok(_inner_resp) => {
                            println!("Wiped data from CoverArt queue");
                            println!("Resp: {_inner_resp:?}");
                            Ok(())
                        }
                        Err(err) => Err(std::io::Error::other(err.to_string())),
                    },
                    Err(err) => Err(std::io::Error::other(err.to_string())),
                }
            }
            Err(err) => Err(std::io::Error::other(err.to_string())),
        },
        Err(err) => Err(std::io::Error::other(err.to_string())),
    }
}

async fn cleanup(
    song: &icarus_models::song::Song,
    coverart: &icarus_models::coverart::CoverArt,
) -> Result<(), std::io::Error> {
    match song.remove_from_filesystem() {
        Ok(_) => {}
        Err(err) => {
            eprintln!("Error: Problem cleaning up SongQueue files {err:?}");
        }
    }

    match coverart.remove_from_filesystem() {
        Ok(_) => Ok(()),
        Err(err) => Err(err),
    }
}

async fn is_queue_empty(
    app: &config::App,
) -> Result<(bool, api::fetch_next_queue_item::response::SongQueueItem), reqwest::Error> {
    match api::fetch_next_queue_item::fetch_next_queue_item(app).await {
        Ok(response) => {
            match response
                .json::<api::fetch_next_queue_item::response::SongQueueItem>()
                .await
            {
                Ok(response) => {
                    if response.data.is_empty() {
                        Ok((true, response))
                    } else {
                        Ok((false, response))
                    }
                }
                Err(err) => Err(err),
            }
        }
        Err(err) => Err(err),
    }
}

async fn some_work(
    app: &crate::config::App,
    song_queue_id: &uuid::Uuid,
    user_id: &uuid::Uuid,
) -> Result<
    (
        icarus_models::song::Song,
        icarus_models::coverart::CoverArt,
        api::get_metadata_queue::response::Metadata,
        queued_item::QueuedSong,
        queued_item::QueuedCoverArt,
    ),
    std::io::Error,
> {
    match prep_song(app, song_queue_id).await {
        Ok((queued_song, queued_coverart, metadata)) => {
            println!("Prepping song");

            match metadata::apply_metadata(&queued_song, &queued_coverart, &metadata).await {
                Ok(_applied) => {
                    match api::update_queued_song::update_queued_song(app, &queued_song).await {
                        Ok(response) => {
                            match response
                                .json::<api::update_queued_song::response::Response>()
                                .await
                            {
                                Ok(_inner_response) => {
                                    println!("Updated queued song");
                                    println!("Response: {_inner_response:?}");

                                    let song_type = String::from(
                                        icarus_meta::detection::song::constants::FLAC_TYPE,
                                    );

                                    match api::create_song::create(
                                        app, &metadata, user_id, &song_type,
                                    )
                                    .await
                                    {
                                        Ok(response) => match response
                                            .json::<api::create_song::response::Response>()
                                            .await
                                        {
                                            Ok(resp) => {
                                                println!("Response: {resp:?}");

                                                let mut song = resp.data[0].clone();
                                                song.directory = queued_song.song.directory.clone();
                                                song.filename = queued_song.song.filename.clone();

                                                match api::create_coverart::create(app, &song, &queued_coverart).await {
                                                    Ok(response) => match response.json::<api::create_coverart::response::Response>().await {
                                                        Ok(resp) => {
                                                            println!("CoverArt sent and successfully parsed response");
                                                            println!("json: {resp:?}");
                                                            let mut coverart = resp.data[0].clone();
                                                            coverart.directory = queued_coverart.coverart.directory.clone();
                                                            coverart.filename = queued_coverart.coverart.filename.clone();

                                                            Ok((song.clone(), coverart.clone(), metadata, queued_song.clone(), queued_coverart.clone()))
                                                        }
                                                        Err(err) => {
                                                            Err(std::io::Error::other(err.to_string()))
                                                        }
                                                    }
                                                    Err(err) => {
                                                        Err(std::io::Error::other(err.to_string()))
                                                    }
                                                }
                                            }
                                            Err(err) => Err(std::io::Error::other(err.to_string())),
                                        },
                                        Err(err) => Err(std::io::Error::other(err.to_string())),
                                    }
                                }
                                Err(err) => Err(std::io::Error::other(err.to_string())),
                            }
                        }
                        Err(err) => Err(std::io::Error::other(err.to_string())),
                    }
                }
                Err(err) => Err(err),
            }
        }
        Err(err) => Err(std::io::Error::other(err.to_string())),
    }
}

async fn prep_song(
    app: &crate::config::App,
    song_queue_id: &uuid::Uuid,
) -> Result<
    (
        queued_item::QueuedSong,
        queued_item::QueuedCoverArt,
        api::get_metadata_queue::response::Metadata,
    ),
    reqwest::Error,
> {
    match api::fetch_song_queue_data::get_data(app, song_queue_id).await {
        Ok(response) => {
            // Process data here...
            match api::parsing::parse_response_into_bytes(response).await {
                Ok(song_bytes) => {
                    let song = icarus_models::song::Song {
                        directory: icarus_envy::environment::get_root_directory().await.value,
                        filename: icarus_models::song::generate_filename(
                            icarus_models::types::MusicTypes::FlacExtension,
                            true,
                        ),
                        data: song_bytes,
                        ..Default::default()
                    };
                    let songpath = song.song_path().unwrap_or_default();

                    let queued_song: crate::queued_item::QueuedSong =
                        match song.save_to_filesystem() {
                            Ok(_) => queued_item::QueuedSong {
                                id: *song_queue_id,
                                song,
                                path: songpath,
                            },
                            Err(err) => {
                                eprintln!("Error: {err:?}");
                                queued_item::QueuedSong {
                                    ..Default::default()
                                }
                            }
                        };

                    println!("Saved at: {:?}", queued_song.path);

                    match api::get_metadata_queue::get(app, &queued_song.id).await {
                        Ok(response) => {
                            match response
                                .json::<api::get_metadata_queue::response::Response>()
                                .await
                            {
                                Ok(response) => {
                                    let id = &response.data[0].id;
                                    let created_at = &response.data[0].created_at;
                                    let metadata = &response.data[0].metadata;
                                    println!("Id: {id:?}");
                                    println!("Metadata: {metadata:?}");
                                    println!("Created at: {created_at:?}");

                                    println!("Getting coverart queue");
                                    match api::get_coverart_queue::get(app, &queued_song.id).await {
                                        Ok(response) => {
                                            match response.json::<api::get_coverart_queue::response::Response>().await {
                                                Ok(response) => {
                                                    let coverart_queue = &response.data[0];
                                                    let coverart_queue_id = coverart_queue.id;
                                                    println!("Coverart queue Id: {coverart_queue_id:?}");

                                                    match api::get_coverart_queue::get_data(app, &coverart_queue_id).await {
                                                        Ok(response) => match api::parsing::parse_response_into_bytes(response).await {
                                                            Ok(coverart_queue_bytes) => {
                                                                let (directory, filename) = generate_coverart_queue_dir_and_filename(&coverart_queue.file_type).await;
                                                                let coverart = icarus_models::coverart::CoverArt {
                                                                    directory,
                                                                    filename,
                                                                    data: coverart_queue_bytes,
                                                                    ..Default::default()
                                                                };
                                                                coverart.save_to_filesystem().unwrap();
                                                                let coverart_queue_fs_path = match coverart.get_path() {
                                                                    Ok(path) => {
                                                                        path
                                                                    }
                                                                    Err(err) => {
                                                                        eprintln!("Error: {err:?}");
                                                                        std::process::exit(-1);
                                                                    }
                                                                };

                                                                let queued_coverart = queued_item::QueuedCoverArt {
                                                                    id: coverart_queue_id,
                                                                    coverart,
                                                                    path: coverart_queue_fs_path
                                                                };

                                                                println!("Saved coverart queue file at: {:?}", queued_coverart.path);

                                                                Ok((queued_song, queued_coverart, metadata.clone()))
                                                            }
                                                            Err(err) => {
                                                                Err(err)
                                                            }
                                                        }
                                                        Err(err) => {
                                                            Err(err)
                                                        }
                                                    }
                                                }
                                                Err(err) => {
                                                    Err(err)
                                                }
                                            }
                                        }
                                        Err(err) => Err(err),
                                    }
                                }
                                Err(err) => Err(err),
                            }
                        }
                        Err(err) => Err(err),
                    }
                }
                Err(err) => Err(err),
            }
        }
        Err(err) => Err(err),
    }
}

// TODO: Consider having something like this in icarus_models
pub async fn generate_coverart_queue_dir_and_filename(file_type: &str) -> (String, String) {
    use rand::Rng;

    let mut filename: String = String::new();
    let filename_len = 10;

    let some_chars: String = String::from("abcdefghij0123456789");
    let mut rng = rand::rng();

    for _ in 0..filename_len {
        let random_number: i32 = rng.random_range(0..=19);
        let index = random_number as usize;
        let rando_char = some_chars.chars().nth(index);

        if let Some(c) = rando_char {
            filename.push(c);
        }
    }

    filename += if file_type == icarus_meta::detection::coverart::constants::JPEG_TYPE
        || file_type == icarus_meta::detection::coverart::constants::JPG_TYPE
    {
        icarus_models::constants::file_extensions::image::JPEGEXTENSION
    } else if file_type == icarus_meta::detection::coverart::constants::PNG_TYPE {
        icarus_models::constants::file_extensions::image::PNGEXTENSION
    } else {
        ""
    };

    // TODO: Consider separating song and coverart when saving to the filesystem
    let directory = icarus_envy::environment::get_root_directory().await.value;

    (directory, filename)
}