#![feature(proc_macro_hygiene, decl_macro)]

#![feature(proc_macro_hygiene, decl_macro, str_split_once)]

use thiserror::Error;

use std::{fs::File, io::Error as IoError};

use std::{fs::File, io::Error as IoError, num::ParseIntError};

#[derive(Debug, Clone, PartialEq, Eq)]

}
#[derive(Error, Debug)]
pub enum SolveRequestError {
    #[error("Request is missing id: u64")]
    MissingId,
    #[error("Request is missing size: usize")]
    MissingSize,
    #[error("More than one ID specified")]
    MoreThanOneId,
    #[error("More than one size specified")]
    MoreThanOneSize,
    #[error("Failed to parse the ID as u64: {_0}")]
    FailedToParseId(#[source] ParseIntError),
    #[error("Failed to parse the size as usize: {_0}")]
    FailedToParseSize(#[source] ParseIntError),
    #[error("No colon between queen coordinates")]
    MissingColonInQueenCoordinates,
    #[error("Failed to parse queen coordinates: {_0}")]
    FailedToParseQueenCoordinates(#[source] ParseIntError),

    type Error = ();

    type Error = SolveRequestError;

        todo!()

        let mut id = Err(SolveRequestError::MissingId);
        let mut size = Err(SolveRequestError::MissingSize);
        let mut fixed_queens = vec![];
        for (key, value) in query.map(|item| item.key_value_decoded()) {
            match key.as_str() {
                "id" => {
                    if id.is_ok() {
                        id = Err(SolveRequestError::MoreThanOneId)
                    } else {
                        id = str::parse(&value)
                            .map_err(|why| SolveRequestError::FailedToParseId(why))
                    }
                }
                "size" => {
                    if size.is_ok() {
                        size = Err(SolveRequestError::MoreThanOneSize)
                    } else {
                        size = str::parse(&value)
                            .map_err(|why| SolveRequestError::FailedToParseSize(why))
                    }
                }
                "queen" => {
                    if let Some((x_coord, y_coord)) = value.split_once(':') {
                        let x_coord = x_coord
                            .parse()
                            .map_err(SolveRequestError::FailedToParseQueenCoordinates)?;
                        let y_coord = y_coord
                            .parse()
                            .map_err(SolveRequestError::FailedToParseQueenCoordinates)?;
                        fixed_queens.push((x_coord, y_coord));
                    } else {
                        return Err(SolveRequestError::MissingColonInQueenCoordinates);
                    }
                }
                _ => {}
            }
        }
        Ok(SolveRequest {
            id: id?,
            size: size?,
            fixed_queens,
        })

fn solve(req: SolveRequest) -> SolveResponse {
    todo!()

fn solve(req: SolveRequest) -> String {
    // TODO (malte): actually do some solving
    format!("{:?}", req)

        .mount("/", routes![index])
        .mount("/solve", routes![solve])

        .mount("/", routes![index, solve])

thiserror = "1.0.22"

 "thiserror",