use serenity::{
  async_trait,
  client::{Context, EventHandler},
  model::gateway::{GatewayIntents, Ready},
  Client,
};
use skynet_discord_bot::common::database::{db_init, DataBase, RoleAdder};
use skynet_discord_bot::{get_config, get_now_iso, Config};
use std::{fs, process, sync::Arc};
use std::ffi::{OsStr, OsString};
use std::fs::File;
use std::io::Read;
use std::path::PathBuf;
use std::process::Command;
use chrono::{Datelike, Utc};
use gdk_pixbuf::{Pixbuf, PixbufFormat, PixbufLoader};
use gdk_pixbuf::prelude::PixbufLoaderExt;
use rand::rngs::SmallRng;
use rand::SeedableRng;
use rand::seq::IndexedRandom;
use resvg::usvg;
use serde::Deserialize;
use serenity::all::GuildId;
use serenity::builder::{CreateAttachment, EditGuild};
use sqlx::{Pool, Sqlite};
use tokio::sync::RwLock;
use skynet_discord_bot::common::renderer::{Args, Renderer};

#[tokio::main]
async fn main() {
  let config = get_config();
  let db = match db_init(&config).await {
    Ok(x) => x,
    Err(_) => return,
  };

  // Intents are a bitflag, bitwise operations can be used to dictate which intents to use
  let intents = GatewayIntents::GUILDS | GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT | GatewayIntents::GUILD_MEMBERS;
  // Build our client.
  let mut client = Client::builder(&config.discord_token, intents)
    .event_handler(Handler {})
    .await
    .expect("Error creating client");

  {
    let mut data = client.data.write().await;

    data.insert::<Config>(Arc::new(RwLock::new(config)));
    data.insert::<DataBase>(Arc::new(RwLock::new(db)));
  }

  if let Err(why) = client.start().await {
    println!("Client error: {:?}", why);
  }
}

struct Handler;
#[async_trait]
impl EventHandler for Handler {
  async fn ready(&self, ctx: Context, ready: Ready) {
    let ctx = Arc::new(ctx);
    println!("{} is connected!", ready.user.name);


    // pull in the open governance repo
    // u[date committee server
    update_icon_main(Arc::clone(&ctx)).await;

    // finish up
    process::exit(0);
  }
}

async fn update_icon_main(ctx: Arc<Context>) {
  let db_lock = {
    let data_read = ctx.data.read().await;
    data_read.get::<DataBase>().expect("Expected Config in TypeMap.").clone()
  };
  let db = db_lock.read().await;

  let config_lock = {
    let data_read = ctx.data.read().await;
    data_read.get::<Config>().expect("Expected Config in TypeMap.").clone()
  };
  
  
  let config_global = config_lock.read().await;
  let config_toml = get_config_icons();
  let server = GuildId::new(689189992417067052);
  
  
  // clone repo into local folder
  clone_repo(&config_global, &config_toml);
  
  // see if there is a current festival
  let festival_data = get_festival(&config_toml);
  
  // get a list of all the graphics files
  let logos = get_logos(&config_global, &config_toml);

  // filter them so only the current season (if any) are active
  let logos_filtered = logos_filter(&festival_data, logos);

  let mut rng = SmallRng::from_os_rng();
  let logo_selected = logos_filtered.choose(&mut rng).unwrap();

  logo_set(&ctx, &db,&server, logo_selected).await;
}

struct FestivalData{
  current: Vec<String>,
  exclusions: Vec<String>,
}

fn get_festival(config_toml: &ConfigToml)-> FestivalData {
  let today = Utc::now();
  let day = today.day();
  let month = today.month();
  let year = today.year();
  
  let mut result = FestivalData {
    current: vec![],
    exclusions: vec![],
  };
  
  for festival in &config_toml.festivals {
    if (day >= festival.start.day && day <= festival.end.day) && 
        (month >= festival.start.month && month <= festival.end.month ) {
      if festival.start.year == 0 || festival.end.year == 0 {
        result.current.push(festival.name.to_owned());
      } else if (year >= festival.start.year && year <= festival.end.year) {
        result.current.push(festival.name.to_owned());
      }
    } else if !festival.all_year {
      result.exclusions.push(festival.name.to_owned());
    }
  }

  result
}

#[derive(Deserialize)]
struct ConfigToml {
  source: ConfigTomlSource,
  festivals: Vec<ConfigTomlFestivals>,
}
#[derive(Deserialize)]
struct ConfigTomlSource {
  repo: String,
  directory: String,
}

#[derive(Deserialize)]
struct ConfigTomlFestivals {
  name: String,
  all_year: bool,
  start: ConfigTomlFestivalsTime,
  end: ConfigTomlFestivalsTime,
}
#[derive(Deserialize)]
struct ConfigTomlFestivalsTime {
  day: u32,
  month: u32,
  year:i32
}

fn get_config_icons() -> ConfigToml {
  let toml_raw = include_str!("../../.server-icons.toml");
  let config: ConfigToml = toml::from_str(toml_raw).unwrap();
  config
}
fn clone_repo(config: &Config, config_toml: &ConfigToml){
  let url = &config_toml.source.repo;
  let folder = format!("{}/open-governance", &config.home);

  Command::new("git")
      .arg("clone")
      .arg(url)
      .arg(&folder)
      .output()
      .expect("failed to execute process");

  Command::new("git")
      .arg("pull")
      .arg("origin")
      .arg("main")
      .current_dir(&folder)
      .output()
      .expect("failed to execute process");
}

fn convert_svg_to_png(original: &PathBuf, out: &PathBuf){
  let mut f = File::open(original).unwrap();
  let mut buffer = Vec::new();
  // read the whole file
  f.read_to_end(&mut buffer).unwrap();
  let loader = PixbufLoader::with_mime_type("image/svg+xml")
      .expect("error loader");
  loader.write(&buffer).expect("TODO: panic message");
  loader.close().expect("TODO: panic message");
  let pixbuf = loader.pixbuf().expect("no pixbuf");

  let (width, height) = (pixbuf.width(), pixbuf.height());
  println!("size: {}x{}", width, height);
  let bytes: Vec<u8> =
      pixbuf.save_to_bufferv("png", &[]).expect("must not error");
  fs::write(out, &bytes).expect("TODO: panic message");
}

struct LogoData {
  name: OsString,
  path: PathBuf,
}
fn get_logos(config: &Config, config_toml: &ConfigToml) ->  Vec<LogoData> {
  let folder = format!("{}/open-governance/{}", &config.home, &config_toml.source.directory);
  let folder_path = PathBuf::from(&folder);
  let mut folder_output = folder_path.clone();
  folder_output.push("converted");
  let paths = fs::read_dir(folder).unwrap();

  let args = Args{
    input: folder_path.clone(),
    output: folder_output,
    colors: String::from(""),
    width: 1024,
    height: 1024,
  };
  let mut r = Renderer::new(&args).unwrap();
  
  let mut logos = vec![];
  
  for tmp in paths.flatten() {
    let path_local = tmp.path().to_owned();
    let path_local2 = tmp.path().to_owned();
    let name = path_local2.file_name().unwrap().to_owned();
    let mut path = tmp.path();
    
    if path.is_dir() {
      continue;
    }

    match tmp.path().extension() {
      None => {}
      Some(ext) => {
        if ext == "svg" {
          let mut path_new = path_local.clone();
          path_new.set_extension("png");
          let filename_tmp = path_new.clone();
          let filename = filename_tmp.file_name().unwrap_or_default();
          path_new.pop();
          path_new.push("converted");
          path_new.push(filename);
          
          // check if exists
          if !path_new.exists() {
            // convert if it hasnt been converted already
            match r.render(&path_local, &args) {
              Ok(_) => log::info!("Successfully rendered all colors of {path_local:?}"),
              Err(e) => {
                log::error!("Failed to render {path_local:?}: {}", e)
              }
            }
          }
          path = path_new;
        }
      }
    };

    logos.push(LogoData{
      name,
      path,
    });

    println!("Name: {}", &tmp.path().display());
  }
  
  logos
}

fn logos_filter(festival_data: &FestivalData, existing: Vec<LogoData>) ->  Vec<LogoData>{
  let mut filtered: Vec<LogoData> = vec![];

  'outer: for logo in existing {
    let name_lowercase0 = logo.name.to_ascii_lowercase();
    let name_lowercase = name_lowercase0.to_str().unwrap_or_default();

    if !festival_data.current.is_empty() {
      // if its a current festival filter based on it
      for festival in &festival_data.current {
        if name_lowercase.contains(festival) {
          filtered.push(logo);
          continue 'outer;
        }
      }
    } else {
      // else filter using the excluded ones
      let mut excluded = false;
      for festival in &festival_data.exclusions {
        if name_lowercase.contains(festival) {
          excluded = true;
        }
      }

      if !excluded {
        filtered.push(logo);
      }
    }
  }

  filtered
}


#[derive(Debug, Clone, sqlx::FromRow)]
pub struct ServerIcons {
  pub id: i64,
  pub name: String,
  pub date: String,
}

async fn logo_set(ctx: &Arc<Context>,  db: &Pool<Sqlite>, server: &GuildId, logo_selected: &LogoData){
  // add to teh database
  logo_set_db(db ,logo_selected).await;

  let icon = CreateAttachment::path(logo_selected.path.to_str().unwrap_or_default()).await.unwrap();

  // assuming a `guild` has already been bound
  let builder = EditGuild::new().icon(Some(&icon));
  server.edit(ctx, builder).await.unwrap();
}

async fn logo_set_db(db: &Pool<Sqlite>, logo_selected: &LogoData){
  let name = logo_selected.name.to_str().unwrap_or_default();

  sqlx::query_as::<_, ServerIcons>(
    "
      INSERT OR REPLACE INTO server_icons (name, date)
      VALUES (?1, ?2, ?3)
    ",
  )
      .bind(name)
      .bind(get_now_iso(false))
      .fetch_optional(db)
      .await;
}

// fn command(config_toml: &ConfigToml, logo_selected: &LogoData){
//   let web_url = format!("{}/src/branch/main/{}/{}",  &config_toml.source.repo, &config_toml.source.directory, &logo_selected.name.to_str().unwrap_or_default());
// }