use clap::Parser;
use serde::{Deserialize, Serialize};

// use crate::commands::{calculate_mapping, execute_pipeline, extrude, flip, palette, remap_image, rescale, rotate, write_palette, FlipDirection, RotateDegree, Rotate};
use crate::commands::{Extrude, Flip, Palette, Pipeline, Reduce, Remap, Rotate, Scale, Split};

use crate::load_image;

/// Crunch is a set of utilities for quickly and easily processing a batch of files, either directly
/// or by defining pipelines
#[derive(Parser, Debug, Clone, Serialize, Deserialize)]
#[clap(name = "crunch")]
#[clap(author = "Louis Capitanchik <louis@microhacks.co.uk>")]
#[clap(version = "0.5.0")]
#[clap(about, long_about = None)]
#[serde(tag = "command", content = "params")]
pub enum Args {
	#[clap(name = "rotate")]
	#[serde(alias = "rotate")]
	Rotate(Rotate),
	#[clap(name = "extrude")]
	#[serde(alias = "extrude")]
	Extrude(Extrude),
	#[clap(name = "palette")]
	#[serde(alias = "palette")]
	Palette(Palette),
	#[clap(name = "scale")]
	#[serde(alias = "scale")]
	Scale(Scale),
	#[clap(name = "flip")]
	#[serde(alias = "flip")]
	Flip(Flip),
	#[clap(name = "remap")]
	#[serde(alias = "remap")]
	Remap(Remap),
	#[clap(name = "pipeline")]
	#[serde(alias = "pipeline")]
	Pipeline(Pipeline),
	#[clap(name = "reduce")]
	#[serde(alias = "reduce")]
	Reduce(Reduce),
	#[clap(name = "split")]
	#[serde(alias = "split")]
	Split(Split),
}

impl Args {
	pub fn run(&self) -> anyhow::Result<()> {
		match &self {
			Args::Rotate(rotate) => {
				let image = load_image(&rotate.input, None)?;
				let output = rotate.run(&image)?;
				output
					.save(rotate.output.as_str())
					.map_err(anyhow::Error::from)
			}
			Args::Extrude(extrude) => {
				let image = load_image(&extrude.input, None)?;
				let output = extrude.run(&image)?;
				output
					.save(extrude.output.as_str())
					.map_err(anyhow::Error::from)
			}
			Args::Palette(palette) => {
				let image = load_image(&palette.input, None)?;
				palette.run(&image)
			}
			Args::Scale(scale) => {
				let image = load_image(&scale.input, None)?;
				let output = scale.run(&image)?;
				output
					.save(scale.output.as_str())
					.map_err(anyhow::Error::from)
			}
			Args::Flip(flip) => {
				let image = load_image(&flip.input, None)?;
				let output = flip.run(&image)?;
				output
					.save(flip.output.as_str())
					.map_err(anyhow::Error::from)
			}
			Args::Remap(remap) => {
				let image_data = load_image(&remap.input, None)?;
				let palette_data = load_image(&remap.palette, None)?;

				let image_palette = Palette::extract_from(&image_data)?;
				let target_palette = Palette::extract_from(&palette_data)?;

				let mappings = Palette::calculate_mapping(&image_palette, &target_palette);
				let output = Remap::remap_image(image_data, mappings)?;

				output.save(&remap.output).map_err(anyhow::Error::from)
			}
			Args::Reduce(reduce) => {
				if let Some(amount) = reduce.colours {
					log::info!("Num cols {}", amount);
				} else {
					log::info!("No Limit");
				}

				Ok(())
			}
			Args::Split(split) => {
				let image = load_image(&split.input, None)?;
				split.run(&image)
			}
			Args::Pipeline(pipeline) => pipeline.execute(),
		}
	}
}