use clap::Parser;
use log::{debug, error, info};
use riki::error::SiteError;
use riki::site::Site;
use riki::util::{canonicalize, copy_file_from_source, mkdir, set_mtime};
use std::error::Error;
use std::path::PathBuf;

const ENVLOG: &str = "RIKI_LOG";

fn main() {
    if let Err(err) = real_main() {
        error!("ERROR: {}", err);
        let mut source = err.source();
        while source.is_some() {
            let s = source.unwrap();
            error!("  caused by: {}", s);
            source = source.unwrap().source();
        }
        std::process::exit(1);
    }
}

fn real_main() -> Result<(), SiteError> {
    if std::env::var(ENVLOG).is_err() {
        std::env::set_var(ENVLOG, "warn");
    }
    pretty_env_logger::init_custom_env(ENVLOG);

    info!("riki starts");

    let args = Args::parse();
    match args.command {
        Command::Build(cmd) => cmd.run()?,
        Command::List(cmd) => cmd.run()?,
    }

    info!("riki ends OK");
    Ok(())
}

#[derive(Parser)]
struct Args {
    #[clap(subcommand)]
    command: Command,
}

#[derive(Parser)]
enum Command {
    Build(Build),
    List(List),
}

#[derive(Parser)]
struct Build {
    #[clap(long)]
    plain_body: bool,

    srcdir: PathBuf,
    destdir: PathBuf,
}

impl Build {
    fn run(&self) -> Result<(), SiteError> {
        let srcdir = canonicalize(&self.srcdir)?;
        debug!("srcdir={}", srcdir.display());

        mkdir(&self.destdir)?;
        let destdir = canonicalize(&self.destdir)?;
        debug!("destdir={}", destdir.display());

        let mut site = Site::new(&srcdir, &destdir);
        site.scan()?;
        site.process()?;
        debug!("markdown file count: {}", site.markdown_pages().len());

        for page in site.markdown_pages() {
            let htmlpage = if self.plain_body {
                page.body_to_html()?
            } else {
                page.to_html()?
            };
            let output = page.meta().destination_filename(&destdir);
            debug!("writing: {}", output.display());
            htmlpage.write(&output)?;
            set_mtime(&output, page.meta().mtime())?;
        }

        for file in site.files() {
            let input = site.input_filename(file)?;
            let output = site.output_filename(file)?;
            copy_file_from_source(&input, &output)?;
        }

        Ok(())
    }
}

#[derive(Parser)]
struct List {
    srcdir: PathBuf,
}

impl List {
    fn run(&self) -> Result<(), SiteError> {
        let srcdir = canonicalize(&self.srcdir)?;
        let mut site = Site::new(&srcdir, &srcdir);
        site.scan()?;
        let mut filenames = site.included_files().to_vec();
        filenames.sort_unstable();
        for filename in filenames {
            println!("{}", filename.display());
        }
        Ok(())
    }
}