use crate::config::{AppConfig, Args, Command};
use crate::links::Link;
use crate::telegram_chat_export::{TelegramChatExport, TextEntity};
use clap::Parser;
use sqlx::SqlitePool;
use std::fs::OpenOptions;
use std::str::FromStr;
use r621::client::{Authentication, Client};
use r621::post::Post;

mod config;
mod links;
mod telegram_chat_export;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let config = AppConfig::new();
    let args = Args::parse();

    match args.command {
        Command::Import { ref path } => {
            import(path, config).await?;
        },
        Command::Unposted => {
            list_unposted_favs(&config).await?;
        }
    }

    Ok(())
}

async fn import(path: &String, config: AppConfig) -> anyhow::Result<()> {
    let mut db = SqlitePool::connect_lazy(&config.database.url)?;
    let import_file = OpenOptions::new().write(false).read(true).open(path)?;

    let telegram_chat_export: TelegramChatExport = serde_json::from_reader(import_file)?;

    import_chat(&telegram_chat_export, &mut db).await?;
    import_messages(&telegram_chat_export, &mut db).await?;

    Ok(())
}

async fn import_chat(
    telegram_chat_export: &TelegramChatExport,
    db: &SqlitePool,
) -> anyhow::Result<()> {
    let transaction = db.begin().await?;
    sqlx::query!(
        "INSERT OR REPLACE INTO chats(id, name) VALUES (?, ?)",
        telegram_chat_export.id,
        telegram_chat_export.name
    )
    .execute(db)
    .await?;

    transaction.commit().await?;
    Ok(())
}

async fn import_messages(
    telegram_chat_export: &TelegramChatExport,
    db: &SqlitePool,
) -> anyhow::Result<()> {
    let transaction = db.begin().await?;
    for message in &telegram_chat_export.messages {
        for entity in &message.text_entities {
            match entity {
                TextEntity::Link { ref text } => {
                    if let Ok(link) = Link::from_str(text) {
                        match link {
                            Link::E621Post { post } => {
                                println!("{link:?}");
                                insert_post(telegram_chat_export.id, message.id, post, db).await;
                            }
                            _ => {}
                        }
                    }
                }
                TextEntity::TextLink { text: _, ref href } => {
                    if let Ok(link) = Link::from_str(href) {
                        println!("{link:?}");
                    }
                }
                _ => {}
            }
        }
    }

    transaction.commit().await?;
    Ok(())
}

async fn insert_post(chat_id: u32, message_id: u32, post_id: u32, db: &SqlitePool) {
    let result = sqlx::query!(
        "INSERT INTO posts(chat, chat_message_id, e621_id) VALUES (?, ?, ?)",
        chat_id,
        message_id,
        post_id
    )
    .execute(db)
    .await;

    if let Err(err) = result {
        eprintln!("{err:?}");
        eprintln!("{chat_id}, {message_id}, {post_id}");
    }
}

async fn list_unposted_favs(config: &AppConfig) -> anyhow::Result<()> {
    let db = SqlitePool::connect_lazy(&config.database.url)?;
    let mut client = Client::new(
        Authentication::Authorized {
            username: &config.e621.username,
            apikey: &config.e621.apikey
        },
        "esix-database/0.1 (by pixelhunter on e621)"
    )?;

    let mut esix_fav_posts = Vec::new();
    let mut postcount = 1;
    let mut page = 1;

    while postcount > 0 {
        println!("Fetching favorites page: {page}, Count: {}", esix_fav_posts.len());
        let current_posts = client.list_posts(None, Some(format!("fav:{}", &config.e621.username)), Some(page)).await?;
        postcount = current_posts.len();
        esix_fav_posts.extend(current_posts);
        page = page+1;
    }

    for fav_post in esix_fav_posts {
        let post_id_i64 = fav_post.id as i64;
        let result = sqlx::query!(
            "SELECT COUNT(*) as count FROM posts WHERE e621_id = ?",
            post_id_i64
        ).fetch_one(&db).await?;

        if result.count == 0 {
            println!("https://www.e621.net/posts/{post_id_i64}");
        }
    }

    Ok(())
}