#![doc(html_root_url = "https://docs.rs/macro_helper/0.1.1/")]
#![no_std]
/*!
This crate is a collection of ligthweight procedural macros typically used for writing others,either procedural or not,as such covers
some of the missing features you might expect from macro_rules! like expansion bucles controlled by you and not an input.Or guarantee an identifier is borrowed in the manner you want over any other,included own.

This crate is **no_std**.
*/

extern crate proc_macro;
extern crate alloc;

use proc_macro::TokenStream;
use core::fmt::Write;
use alloc::{ string::{String, ToString}, vec::Vec, format };

fn ops(input: TokenStream) -> TokenStream {
    let input = input.to_string();

    let mut operators = String::with_capacity(input.len());
    let mut err = String::with_capacity(64);

    let mut it: Vec<String> = input.split(|c: char| {
        match c {
            '+' => {operators.push('+'); true},
            '-' => {operators.push('-'); true},
            '*' => {operators.push('*'); true},
            '/' => {operators.push('/'); true},
            '%' => {operators.push('%'); true},
            '^' => {operators.push('^'); true},
            _ => false   
        }
    }).map(|e| e.chars().filter(|c| c.is_numeric()).collect() ).collect();

    let mut result: isize = it[0].parse().unwrap_or_else(|_| {
        err.push_str("compile_error!(\"Error at parsing first operand.\")");
        0
    });

    if err != "" {
        return err.parse().unwrap();
    }

    for (i, (e, op)) in it.drain(1..).zip(operators.chars()).enumerate() {

        if e == "" {
            return format!("compile_error!(\"Error at parsing operand number {}.\")", i+1).parse().unwrap()
        }

        let e: isize = match e.parse() {
            Ok(i) => i,
            Err(_) => return format!("compile_error!(\"Error operand number {} overflows an isize.\")", i+1).parse().unwrap(),
        };

        match op {
            '+' => result = match result.checked_add(e) {
                Some(i) => i,
                None => return format!("compile_error!(\"operation number {} failed.\")", i+1).parse().unwrap(),
            },

            '-' => result = match result.checked_sub(e) {
                Some(i) => i,
                None => return format!("compile_error!(\"operation number {} failed.\")", i+1).parse().unwrap(),
            },

            '*' => result = match result.checked_mul(e) {
                Some(i) => i,
                None => return format!("compile_error!(\"operation number {} failed.\")", i+1).parse().unwrap(),
            },

            '/' => result = match result.checked_div(e) {
                Some(i) => i,
                None => return format!("compile_error!(\"operation number {} failed.\")", i+1).parse().unwrap(),
            },

            '%' => result = match result.checked_rem(e) {
                Some(i) => i,
                None => return format!("compile_error!(\"operation number {} failed.\")", i+1).parse().unwrap(),
            },

            '^' => result = match result.checked_pow(e as u32) {
                Some(i) => i,
                None => return format!("compile_error!(\"operation number {} failed.\")", i+1).parse().unwrap(),
            },

            _ => ()
        }        
    }

    result.to_string().parse().unwrap()
}

/// An expansion bucle with syntax **code => num** when num is the number of times the code should be expanded.
/// 
/// The num part supports encoded arithmetic operations.
/// 
/// Note that a zero not throws an compiler error rather than that it expands zero times the given code.
#[proc_macro]
pub fn expansion_bucle(input: TokenStream) -> TokenStream {
    let mut expansion = String::new();
    let input = input.to_string();
    let index = input.rfind("=>").unwrap_or_else(|| 1);
    
    let (mut code, mut repetitions) = input.split_at(index);
    repetitions = (&repetitions[2..]).trim();
    let mathematic = repetitions.contains(|c: char| {
        match c {
            '+' => true,
            '-' => true,
            '*' => true,
            '/' => true,
            '%' => true,
            '^' => true,
            _ => false   
        }
    });

    let rep: TokenStream = repetitions.to_string().parse().unwrap();

    let repetitions = if mathematic {
        ops(rep).to_string().parse::<usize>().unwrap()
    } else {
        repetitions.parse::<usize>().unwrap()
    };

    code = code.trim();

    if repetitions == 0 {
        return expansion.parse().unwrap();
    }

    expansion.reserve(code.len()*repetitions);

    for _ in 0..repetitions {
        expansion.push_str(code);
    }

    expansion.parse().unwrap()  
} 

/// An expansion bucle with syntax **code => num** when num is the number of times the code should be expanded along with a
/// declaration of the **rep_count** integer variable at start of each "iteration" counting them from 0 thought num-1.
/// 
/// The num part supports encoded arithmetic operations.
/// 
/// Note that a zero not throws an compiler error rather than that it expands zero times the given code.
#[proc_macro]
pub fn expansion_bucle_counted(input: TokenStream) -> TokenStream {
    let mut expansion = String::new();
    let input = input.to_string();
    let index = input.rfind("=>").unwrap_or_else(|| 1);
    
    let (mut code, repetitions) = input.split_at(index);
    let repetitions = (&repetitions[2..]).trim();

    let mathematic = repetitions.contains(|c: char| {
        match c {
            '+' => true,
            '-' => true,
            '*' => true,
            '/' => true,
            '%' => true,
            '^' => true,
            _ => false   
        }
    });

    let rep: TokenStream = repetitions.to_string().parse().unwrap();

    let repetitions = if mathematic {
        ops(rep).to_string().parse::<usize>().unwrap()
    } else {
        repetitions.parse::<usize>().unwrap()
    };

    code = code.trim();

    if repetitions == 0 {
        return expansion.parse().unwrap();
    }

    expansion.reserve((code.len()+25)*repetitions);

    for i in 0..repetitions {
        writeln!(expansion, "let rep_count = {};", i).unwrap();
        expansion.push_str(code);
    }

    expansion.parse().unwrap()
} 

/// Ensures that the reference or identifier passed is shared and changes it if is not.
/// 
/// Typically useless because inside macros it ignores the namespace of the tokens captured by input and returns one that doesn't
/// have always a declared identifier.This will change if the hygiene of the procedural macros is sync with the by-example ones.
#[proc_macro]
pub fn as_ref_token(input: TokenStream) -> TokenStream {
    let input = input.to_string();
    let inputt = input.trim();
    let bool1 = input.contains('&');

    if bool1 && !inputt.contains("&mut") {
        inputt.parse().unwrap()
    } else {
        let index = if bool1 { inputt.rfind(' ').unwrap()+1 } else { 0 };
        format!("&{}", &inputt[index..]).parse().unwrap()
    }
}

/// Ensures that the reference or identifier passed is mutable and changes it if is not.
/// 
/// Typically useless because inside macros it ignores the namespace of the tokens captured by input and returns one that doesn't
/// have always a declared identifier.This will change if the hygiene of the procedural macros is sync with the by-example ones.
#[proc_macro]
pub fn as_mut_ref_token(input: TokenStream) -> TokenStream {
    let input = input.to_string();
    let inputt = input.trim();
    let bool1 = input.contains('&');

    if bool1 && inputt.contains("&mut") {
        inputt.parse().unwrap()
    } else {
        let a = if bool1 {1} else {0};
        format!("&mut {}", &inputt[a..]).parse().unwrap()
    }
}

/// Eval encoded strings that maybe are from other macros.
/// 
/// The unique thing this macro does is omit the first and last token,that is,the quote `"`.This might be
/// useful when you receive a str into a macro and you want evaluate they to not waste more code in 
/// replicate the behaviour,while you also want the string for other things,saving you from a possible parse.
/// 
/// The indentifiers are parsed literally in procedural macros so this macro is not a security problem 
/// as a true eval is in a scripted language. 
#[proc_macro]
pub fn eval_encoded(input: TokenStream) -> TokenStream {
    let input = input.to_string();
    (&input[1..input.len()-1]).to_string().parse().unwrap()
}