use serde::Deserialize;
use std::{ffi::OsString, fs, path::PathBuf};

pub mod get_config_icons {
  use super::*;
  use crate::Config;

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

  #[derive(Deserialize)]
  pub struct ConfigTomlLocal {
    pub source: ConfigTomlSource,
  }
  #[derive(Deserialize)]
  pub struct ConfigTomlRemote {
    pub festivals: Vec<ConfigTomlFestivals>,
  }

  #[derive(Deserialize, Debug)]
  pub struct ConfigTomlSource {
    pub repo: String,
    pub directory: String,
    pub file: String,
  }

  #[derive(Deserialize, Debug)]
  pub struct ConfigTomlFestivals {
    pub name: String,
    pub all_year: bool,
    pub start: ConfigTomlFestivalsTime,
    pub end: ConfigTomlFestivalsTime,
  }

  #[derive(Deserialize, Debug)]
  pub struct ConfigTomlFestivalsTime {
    pub day: u32,
    pub month: u32,
    pub year: i32,
  }
  pub fn minimal() -> ConfigTomlLocal {
    let toml_raw_min = include_str!("../../.server-icons.toml");
    let config_min: ConfigTomlLocal = toml::from_str(toml_raw_min).unwrap();
    config_min
  }

  // since a copy of the festival file is in the repo we just need to get to it
  pub fn full(config: &Config) -> ConfigToml {
    let config_source = minimal();

    let file_path = format!("{}/open-governance/{}/{}", &config.home, &config_source.source.directory, &config_source.source.file);
    let contents = fs::read_to_string(file_path).expect("Should have been able to read the file");
    let config_festivals: ConfigTomlRemote = toml::from_str(&contents).unwrap();

    ConfigToml {
      source: config_source.source,
      festivals: config_festivals.festivals,
    }
  }
}

#[derive(Debug)]
pub struct LogoData {
  pub name: OsString,
  pub path: PathBuf,
}

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

pub mod update_icon {
  use super::*;
  use crate::{
    common::{
      renderer::{Args, Renderer},
      server_icon::get_config_icons::{self, ConfigToml, ConfigTomlLocal},
    },
    get_now_iso, Config,
  };
  use chrono::{Datelike, Utc};
  use rand::{rngs::SmallRng, seq::IndexedRandom, SeedableRng};
  use serenity::{
    all::GuildId,
    builder::{CreateAttachment, EditGuild},
    client::Context,
  };
  use sqlx::{Pool, Sqlite};
  use std::process::Command;

  /// Update the server icon, pulling from open governance.
  pub async fn update_icon_main(ctx: &Context, db: &Pool<Sqlite>, config_global: &Config, config_toml_local: &ConfigTomlLocal) {
    let server = GuildId::new(689189992417067052);

    // clone repo into local folder
    clone_repo(config_global, config_toml_local);

    // now the repo has been downloaded/updated we can now access the festivals
    let config_toml = get_config_icons::full(config_global);

    // 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;
  }

  #[derive(Debug)]
  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 || (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
  }

  fn clone_repo(config: &Config, config_toml: &ConfigTomlLocal) {
    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 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(_) => {}
                Err(_e) => {
                  dbg!("Failed to render {path_local:?}: {}");
                }
              }
            }
            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
  }

  async fn logo_set(ctx: &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();

    match sqlx::query_as::<_, ServerIcons>(
      "
      INSERT OR REPLACE INTO server_icons (name, date)
      VALUES (?1, ?2)
    ",
    )
    .bind(name)
    .bind(get_now_iso(false))
    .fetch_optional(db)
    .await
    {
      Ok(_) => {}
      Err(e) => {
        dbg!(e);
      }
    }
  }
}