use std::fmt::{self, Write as _};

use anyhow::{anyhow, Result};
use clap::{Parser, ValueEnum};
use serde::Deserialize;

#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
enum LintGroup {
    Cargo,
    Complexity,
    Correctness,
    Nursery,
    Pedantic,
    Perf,
    Restriction,
    Style,
    Suspicious,
    Deprecated,
}

#[derive(Clone, Copy, Debug, ValueEnum)]
enum Profile {
    Publish,
    Personal,
}

#[derive(Parser, Debug)]
struct Args {
    #[arg(long)]
    profile: Profile,

    #[arg(long)]
    workspace: bool,
}

impl LintGroup {
    fn as_str(self) -> &'static str {
        match self {
            Self::Cargo => "cargo",
            Self::Complexity => "complexity",
            Self::Correctness => "correctness",
            Self::Nursery => "nursery",
            Self::Pedantic => "pedantic",
            Self::Perf => "perf",
            Self::Restriction => "restriction",
            Self::Style => "style",
            Self::Suspicious => "suspicious",
            Self::Deprecated => "deprecated",
        }
    }
}

impl fmt::Display for LintGroup {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

#[derive(Clone, Copy, Debug, Deserialize)]
#[serde(rename_all = "lowercase")]
enum LintLevel {
    Allow,
    Warn,
    Deny,
    None,
}

impl LintLevel {
    fn as_str(self) -> &'static str {
        match self {
            Self::Allow => "allow",
            Self::Warn => "warn",
            Self::Deny => "deny",
            Self::None => "none",
        }
    }
}

#[derive(Clone, Debug, Deserialize)]
#[expect(dead_code, reason = "this is an external data definition")]
struct Lint {
    id: LintId,
    group: LintGroup,
    #[serde(rename = "level")]
    default_level: LintLevel,
    version: String,
}

#[derive(Clone, Copy, Debug)]
enum PrioritySetting {
    Explicit(isize),
    Unspecified,
}

#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
struct LintId(String);

impl fmt::Display for LintId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

struct LintList(Vec<LintId>);

impl From<Vec<&str>> for LintList {
    fn from(value: Vec<&str>) -> Self {
        Self(value.into_iter().map(|s| LintId(s.to_owned())).collect())
    }
}

#[derive(Debug)]
struct SingleLintConfig {
    lint: LintId,
    priority: PrioritySetting,
    level: LintLevel,
}

#[derive(Debug)]
struct GroupConfig {
    group: LintGroup,
    priority: PrioritySetting,
    level: LintLevel,
}

#[derive(Debug)]
enum Setting {
    Single(SingleLintConfig),
    Group(GroupConfig),
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum ExhaustiveGroupClassification {
    Default,
    Exception,
}

#[derive(Debug)]
struct ExhausiveGroup {
    defaults: Vec<Setting>,
    exceptions: Vec<Setting>,
}

struct Exceptions {
    level: LintLevel,
    lints: LintList,
}

impl Setting {
    fn set_group(group: LintGroup, priority: PrioritySetting, level: LintLevel) -> Self {
        Self::Group(GroupConfig {
            group,
            priority,
            level,
        })
    }
    fn warn_group(group: LintGroup, priority: PrioritySetting) -> Self {
        Self::set_group(group, priority, LintLevel::Warn)
    }

    fn deny_group(group: LintGroup, priority: PrioritySetting) -> Self {
        Self::set_group(group, priority, LintLevel::Deny)
    }

    fn allow(response: &Response, group: LintGroup, lints: &[&str]) -> Result<Vec<Self>> {
        lints
            .iter()
            .map(|lint| {
                let lint = LintId((*lint).to_owned());
                let found = response.0.iter().find(|r| r.id == lint && r.group == group);
                if found.is_none() {
                    Err(anyhow!("lint {} not in group {}", lint, group.as_str()))
                } else {
                    Ok(Self::Single(SingleLintConfig {
                        lint,
                        priority: PrioritySetting::Unspecified,
                        level: LintLevel::Allow,
                    }))
                }
            })
            .collect()
    }

    fn split_group_exhaustive(
        response: &Response,
        group: LintGroup,
        default_level: LintLevel,
        exceptions: &Exceptions,
    ) -> Result<ExhausiveGroup> {
        let all_lints_in_group: Vec<LintId> = response
            .0
            .iter()
            .filter_map(|lint| {
                if lint.group == group {
                    Some(lint.id.clone())
                } else {
                    None
                }
            })
            .collect();

        if let Some(err) = exceptions.lints.0.iter().find_map(|lint| {
            if !all_lints_in_group.contains(lint) {
                Some(anyhow!("lint {lint} not part of group {group}"))
            } else {
                None
            }
        }) {
            return Err(err);
        };

        Ok(all_lints_in_group
            .into_iter()
            .map(|lint| {
                if exceptions.lints.0.contains(&lint) {
                    (
                        ExhaustiveGroupClassification::Exception,
                        Self::Single(SingleLintConfig {
                            lint,
                            priority: PrioritySetting::Unspecified,
                            level: exceptions.level,
                        }),
                    )
                } else {
                    (
                        ExhaustiveGroupClassification::Default,
                        Self::Single(SingleLintConfig {
                            lint,
                            priority: PrioritySetting::Unspecified,
                            level: default_level,
                        }),
                    )
                }
            })
            .fold(
                ExhausiveGroup {
                    defaults: Vec::new(),
                    exceptions: Vec::new(),
                },
                |mut acc, (classification, setting)| {
                    match classification {
                        ExhaustiveGroupClassification::Default => acc.defaults.push(setting),
                        ExhaustiveGroupClassification::Exception => acc.exceptions.push(setting),
                    };
                    acc
                },
            ))
    }
}

#[derive(Debug)]
struct ConfigGroup {
    comment: Option<String>,
    settings: Vec<Setting>,
}

#[derive(Debug)]
struct Config(Vec<ConfigGroup>);

impl Config {
    fn to_toml(&self, args: &Args) -> String {
        let mut output = if args.workspace {
            String::from("[workspace.lints.clippy]\n")
        } else {
            String::from("[lints.clippy]\n")
        };

        let mut iter_group = self.0.iter().peekable();

        while let Some(group) = iter_group.next() {
            let last_group = iter_group.peek().is_none();
            if let Some(ref comment) = group.comment {
                writeln!(output, "# {comment}").expect("writing to string succeeds");
            }

            let mut iter_setting = group.settings.iter().peekable();
            while let Some(setting) = iter_setting.next() {
                let last_setting = iter_setting.peek().is_none();
                match *setting {
                    Setting::Single(ref single_lint_config) => match single_lint_config.priority {
                        PrioritySetting::Explicit(priority) => write!(
                            output,
                            "{} = {{ level = \"{}\", priority = {} }}",
                            single_lint_config.lint.0,
                            single_lint_config.level.as_str(),
                            priority
                        )
                        .expect("writing to string succeeds"),
                        PrioritySetting::Unspecified => write!(
                            output,
                            "{} = \"{}\"",
                            single_lint_config.lint.0,
                            single_lint_config.level.as_str()
                        )
                        .expect("writing to string succeeds"),
                    },
                    Setting::Group(ref group_config) => match group_config.priority {
                        PrioritySetting::Explicit(priority) => write!(
                            output,
                            "{} = {{ level = \"{}\", priority = {} }}",
                            group_config.group.as_str(),
                            group_config.level.as_str(),
                            priority
                        )
                        .expect("writing to string succeeds"),
                        PrioritySetting::Unspecified => write!(
                            output,
                            "{} = \"{}\"",
                            group_config.group.as_str(),
                            group_config.level.as_str(),
                        )
                        .expect("writing to string succeeds"),
                    },
                };
                if !last_setting {
                    output.push('\n');
                }
                if last_setting && !last_group {
                    output.push('\n');
                }
            }
            if !last_group {
                output.push('\n');
            }
        }

        output
    }
}

#[derive(Debug, Deserialize)]
struct Response(Vec<Lint>);

fn main() -> Result<()> {
    let args = Args::parse();

    let response: Response = ureq::get("https://rust-lang.github.io/rust-clippy/stable/lints.json")
        .call()?
        .into_json()?;

    let restriction_group = Setting::split_group_exhaustive(
        &response,
        LintGroup::Restriction,
        LintLevel::Allow,
        &Exceptions {
            level: LintLevel::Warn,
            lints: vec![
                "allow_attributes",
                "allow_attributes_without_reason",
                "arithmetic_side_effects",
                "as_conversions",
                "assertions_on_result_states",
                "cfg_not_test",
                "clone_on_ref_ptr",
                "create_dir",
                "dbg_macro",
                "decimal_literal_representation",
                "default_numeric_fallback",
                "deref_by_slicing",
                "disallowed_script_idents",
                "else_if_without_else",
                "empty_drop",
                "empty_enum_variants_with_brackets",
                "empty_structs_with_brackets",
                "exit",
                "filetype_is_file",
                "float_arithmetic",
                "float_cmp_const",
                "fn_to_numeric_cast_any",
                "format_push_string",
                "get_unwrap",
                "indexing_slicing",
                "infinite_loop",
                "inline_asm_x86_att_syntax",
                "inline_asm_x86_intel_syntax",
                "integer_division",
                "iter_over_hash_type",
                "large_include_file",
                "let_underscore_must_use",
                "let_underscore_untyped",
                "little_endian_bytes",
                "lossy_float_literal",
                "map_err_ignore",
                "mem_forget",
                "missing_assert_message",
                "missing_asserts_for_indexing",
                "mixed_read_write_in_expression",
                "modulo_arithmetic",
                "multiple_inherent_impl",
                "multiple_unsafe_ops_per_block",
                "mutex_atomic",
                "panic",
                "partial_pub_fields",
                "pattern_type_mismatch",
                "print_stderr",
                "print_stdout",
                "pub_without_shorthand",
                "rc_buffer",
                "rc_mutex",
                "redundant_type_annotations",
                "renamed_function_params",
                "rest_pat_in_fully_bound_structs",
                "same_name_method",
                "self_named_module_files",
                "semicolon_inside_block",
                "str_to_string",
                "string_add",
                "string_lit_chars_any",
                "string_slice",
                "string_to_string",
                "suspicious_xor_used_as_pow",
                "tests_outside_test_module",
                "todo",
                "try_err",
                "undocumented_unsafe_blocks",
                "unimplemented",
                "unnecessary_safety_comment",
                "unnecessary_safety_doc",
                "unnecessary_self_imports",
                "unneeded_field_pattern",
                "unseparated_literal_suffix",
                "unused_result_ok",
                "unwrap_used",
                "use_debug",
                "verbose_file_reads",
            ]
            .into(),
        },
    )?;

    let config = Config(vec![
        ConfigGroup {
            comment: Some("enabled groups".to_owned()),
            settings: vec![
                Setting::deny_group(LintGroup::Correctness, PrioritySetting::Explicit(-1)),
                Setting::warn_group(LintGroup::Suspicious, PrioritySetting::Explicit(-1)),
                Setting::warn_group(LintGroup::Style, PrioritySetting::Explicit(-1)),
                Setting::warn_group(LintGroup::Complexity, PrioritySetting::Explicit(-1)),
                Setting::warn_group(LintGroup::Perf, PrioritySetting::Explicit(-1)),
                Setting::warn_group(LintGroup::Cargo, PrioritySetting::Explicit(-1)),
                Setting::warn_group(LintGroup::Pedantic, PrioritySetting::Explicit(-1)),
                Setting::warn_group(LintGroup::Nursery, PrioritySetting::Explicit(-1)),
            ],
        },
        ConfigGroup {
            comment: Some("pedantic overrides".to_owned()),
            settings: Setting::allow(
                &response,
                LintGroup::Pedantic,
                &[
                    "too_many_lines",
                    "must_use_candidate",
                    "map_unwrap_or",
                    "missing_errors_doc",
                    "if_not_else",
                ],
            )?,
        },
        ConfigGroup {
            comment: Some("nursery overrides".to_owned()),
            settings: Setting::allow(
                &response,
                LintGroup::Nursery,
                &["missing_const_for_fn", "option_if_let_else"],
            )?,
        },
        ConfigGroup {
            comment: Some("complexity overrides".to_owned()),
            settings: Setting::allow(&response, LintGroup::Complexity, &["too_many_arguments"])?,
        },
        ConfigGroup {
            comment: Some("style overrides".to_owned()),
            settings: Setting::allow(&response, LintGroup::Style, &["new_without_default"])?,
        },
        ConfigGroup {
            comment: Some("cargo overrides".to_owned()),
            settings: Setting::allow(&response, LintGroup::Cargo, &{
                let mut v = vec!["multiple_crate_versions"];
                match args.profile {
                    Profile::Publish => (),
                    Profile::Personal => v.push("cargo_common_metadata"),
                }
                v
            })?,
        },
        ConfigGroup {
            comment: Some("selected restrictions".to_owned()),
            settings: restriction_group.exceptions,
        },
        ConfigGroup {
            comment: Some("restrictions explicit allows".to_owned()),
            settings: restriction_group.defaults,
        },
    ]);

    let output = config.to_toml(&args);

    #[expect(clippy::print_stdout, reason = "this is the main program output")]
    {
        println!("{output}");
    }

    Ok(())
}