import java.util.ArrayList;
import java.util.Collections;

public class Atom {
    //  Declaro el constructor de Atom.
    public Atom(AtomType at, ArrayList<Character> chars) {
        this.atomType = at;
        this.matchingChars = chars;
    }

    //  Declaro los atributos que tendrá un Atom.
    private AtomType atomType;
    private ArrayList<Character> matchingChars;


    //  Declaro los getters de los atributos de Atom.
    public ArrayList<Character> getMatchingChars() {
        return matchingChars;
    }

    public AtomType getAtomType() {
        return atomType;
    }

    //  matches() revisará si el atom y el caracter del texto de ese momento son iguales.
    public boolean matches(Character currentAtom) {
        for (Character c : matchingChars) {
            if (c.equals(currentAtom)) return true;
        }
        return false;
    }

    //  Este es el enum que me indicará que tipo de Atom tenemos en cada momento.
    enum AtomType {
        LIST, AT_START, AT_END, CLOSURE, ALL, CHARACTER
    }

    //  A partir de un String, devolveré un ArrayList de Atoms.
    static ArrayList<Atom> getAtoms(String s) {
        //  Declaro un ArraList de tokens y un char que me indicará el Atom actual.
        ArrayList<Atom> atoms = new ArrayList<>();
        char currentAtom;
        for (int i = 0; i < s.length(); i++) {
            //  Añadimos en currentAtom cada valor del String.
            currentAtom = s.charAt(i);
            //  Revisamos si nos encontramos un '%' y si es la primera vez que pasamos.
            if (currentAtom == '%' && i == 0) {
                //  Guardamos el valor siguiente en currentAtom ya que necesitamos guardar el valor siguiente.
                currentAtom = s.charAt(++i);
                //  Añadimos al ArrayList un nuevo Atom de tipo AT_START, y añado en un arrayList el currentAtom.
                atoms.add(new Atom(AtomType.AT_START, newArrayListWithChars(currentAtom)));
            }
            //  Realizamos la misma estructura para el resto de metacarácteres.
            else if (currentAtom == '@') {
                currentAtom = s.charAt(++i);
                atoms.add(new Atom(AtomType.CHARACTER, newArrayListWithChars(currentAtom)));
            } else if (currentAtom == '?') {
                //  En este caso no hace falta pasarle un character.
                atoms.add(new Atom(AtomType.ALL, null));
            } else if (currentAtom == '[') {
                //  Guardamos el valor de la posición del caracter ']'
                //  y pasamos a la función buildList el substring de '[' a ']'.
                int endOfListPos = s.indexOf(']', i);
                atoms.add(new Atom(AtomType.LIST, buildList(s.substring(i + 1, endOfListPos))));
                //  Por último pasamos la i a la posición de endOfListPos.
                i = endOfListPos;
            } else if (currentAtom == '+') {
                atoms.add(new Atom(AtomType.CLOSURE, atoms.get(atoms.size() - 1).getMatchingChars()));
            } else if (currentAtom == '*') {
                currentAtom = s.charAt(i - 1);
                atoms.remove(atoms.size() - 1);
                atoms.add(new Atom(AtomType.CLOSURE, newArrayListWithChars(currentAtom)));
           /*     atoms.add(new Atom(AtomType.CLOSURE, atoms.get(atoms.size() - 1).getMatchingChars()));
                atoms.remove(atoms.size() - 2);
                */
            }
            //  Si el valor que nos encontramos es un dolar y está en la última posición del String, será un Atom AT_END.
            else if (currentAtom == '$' && i == s.length() - 1) {
                //  Guardamos en currentAtom el valor anterior del String.
                currentAtom = s.charAt(i - 1);
                //  Eliminamos el atom anterior y los guardamos otra vez siendo un AT_END.
                atoms.remove(atoms.size() - 1);
                atoms.add(new Atom(AtomType.AT_END, newArrayListWithChars(currentAtom)));
            } else {
                //  Si no entrá en el resto de if, será un carácter.
                atoms.add(new Atom(AtomType.CHARACTER, newArrayListWithChars(currentAtom)));
            }
        }
        return atoms;
    }

    //  Está función me devolverá un arrayList de caracteres con el valor de currentChar añadido.
    private static ArrayList<Character> newArrayListWithChars(char currentChar) {
        ArrayList<Character> result = new ArrayList<>();
        result.add(currentChar);
        return result;
    }


    @Override
    public String toString() {
        return String.format("AtomType: %s, Chars: %s", this.atomType, this.matchingChars);
    }

    //  BuildList generará un ArrayList de caracteres que nos indiquen en el rango ([ ]).
    private static ArrayList<Character> buildList(String s) {
        //  Declaro un ArrayList donde añadiré los carácteres y un int llamado hyphenPos, que me indicará la posición del guón.
        ArrayList<Character> result = new ArrayList<>();
        int hyphenPos;
        //  Este bucle me indica si el String tiene (uno o muchos) guiones.
        while ((hyphenPos = s.indexOf('-')) != -1) {
            // Si tiene guión, llamo a la funcion addCharSequence y le paso los valores que se encuentran a la izquierda
            //  y a la derecha del guión.
            result = addCharSequence(s.charAt(hyphenPos - 1), s.charAt(hyphenPos + 1));
            // Una vez rellenado, sobreescribo el string quitandole los dos valores de alrededor (guión incluido).
            s = s.substring(0, hyphenPos - 1) + s.substring(hyphenPos + 2);
        }
        //  Si no quedan guiones, añado cada valor que quede directamente.
        for (char c : s.toCharArray()) {
            result.add(c);
        }
        return result;
    }

    //  Esta función añade en un ArrayList todos los valores que se encuentran entre cada uno de los caracteres.
    private static ArrayList<Character> addCharSequence(int firstChar, int lastChar) {
        ArrayList<Character> result = new ArrayList<>();
        //  Mientras el segundo valor sea mayor o igual al primero, añadiremos dicho valor al ArrayList y lo decrementaremos.
        while (lastChar >= firstChar) {
            result.add((char) lastChar);
            lastChar--;
        }
        //  Por estetica, Ordeno el ArrayList por ordén alfabético y lo devuelvo.
        Collections.sort(result);
        return result;
    }
}