//! A macro to document enum variants with the things that they are compatible with.

//!

//!

//! As well as documenting each variant, this macro also generates lists of all compatible variants

//! for each "thing".

//!

//! # Motivation

//!

//! This macro is used in Conjure-Oxide, a constraint modelling tool with support for multiple

//! backend solvers (e.g. Minion, SAT).

//!

//! The Conjure-Oxide AST is used as the singular representation for constraints models throughout

//! its crate. A consequence of this is that the AST must contain all possible supported

//! expressions for all solvers, as well as the high level Essence language it takes as input.

//! Therefore, only a small subset of AST nodes are useful for a particular solver.

//!

//! The documentation this generates helps rewrite rule implementers determine which AST nodes are

//! used for which backends by grouping AST nodes per solver.

#![allow(clippy::unwrap_used)]

#![allow(unstable_name_collisions)]

use proc_macro::TokenStream;

use std::collections::HashMap;

use itertools::Itertools;

use quote::quote;

use syn::{

    Attribute, Fields, ItemEnum, Meta, Token, Variant, parse_macro_input, parse_quote,

    punctuated::Punctuated, visit_mut::VisitMut,

};

// A nice S.O answer that helped write the syn code :)

// https://stackoverflow.com/a/65182902

struct RemoveCompatibleAttrs;

impl VisitMut for RemoveCompatibleAttrs {

        // 1. generate docstring for variant

        // Supported by: minion, sat ...

        //

        // 2. delete #[compatible] attributes

        }

}

/// A macro to document enum variants by the things that they are compatible with.

///

/// # Examples

///

/// ```

/// use conjure_cp_enum_compatibility_macro::document_compatibility;

///

/// #[document_compatibility]

/// pub enum Expression {

///    #[compatible(Minion)]

///    ConstantInt(i32),

///    // ...

///    #[compatible(Chuffed)]

///    #[compatible(Minion)]

///    Sum(Vec<Expression>)

///    }

/// ```

///

/// The Expression type will have the following lists appended to its documentation:

///

///```text

/// ## Supported by `minion`

///    ConstantInt(i32)

///    Sum(Vec<Expression>)

///

///

/// ## Supported by `chuffed`

///    ConstantInt(i32)

///    Sum(Vec<Expression>)

/// ```

///

/// Two equivalent syntaxes exist for specifying supported solvers:

///

/// ```

///# use conjure_cp_enum_compatibility_macro::document_compatibility;

///#

///# #[document_compatibility]

///# pub enum Expression {

///#    #[compatible(Minion)]

///#    ConstantInt(i32),

///#    // ...

///     #[compatible(Chuffed)]

///     #[compatible(Minion)]

///     Sum(Vec<Expression>)

///#    }

/// ```

///

/// ```

///# use conjure_cp_enum_compatibility_macro::document_compatibility;

///#

///# #[document_compatibility]

///# pub enum Expression {

///#    #[compatible(Minion)]

///#    ConstantInt(i32),

///#    // ...

///     #[compatible(Minion,Chuffed)]

///     Sum(Vec<Expression>)

///#    }

/// ```

///

#[proc_macro_attribute]

    // Parse the input tokens into a syntax tree

    // process each item inside the enum.

                };

            }

        }

    }

    // we must remove all references to #[compatible] before we finish expanding the macro,

    // as it does not exist outside of the context of this macro.

    // Build the doc string.

    // Note that quote wants us to build the doc message first, as it cannot interpolate doc

    // comments well.

    // https://docs.rs/quote/latest/quote/macro.quote.html#interpolating-text-inside-of-doc-comments

        // a nice title

        // list all the ast nodes for this solver

        // end list

    }

        #input

    };

/// Generate a `discriminant_from_name!` macro and `discriminant_from_value` function for an enum.

///

/// The generated discriminants are `1..=variant_count`, in source definition order.

///

/// # Caveat

///

/// This emits items with fixed names into the surrounding module, so using it for multiple enums

/// in the same module will cause name collisions.

#[proc_macro_attribute]

            (#variant_ident) => { #discriminant };

        }

        };

            #pattern => #discriminant,

        }

        #input

        #[macro_export]

        macro_rules! discriminant_from_name {

            #(#name_arms)*

        }

        #[allow(dead_code)]

        #fn_vis fn discriminant_from_value #fn_generics (

            value: &#enum_ident #ty_generics

        ) -> usize

        #where_clause

        {

            match value {

                #(#value_arms)*

            }

        }

    };