import java.util.ArrayList;

public class Find {

    private String text;

    public Find(String text) {
        this.text = text;
    }

    //  En este match recibimos el String llamado StringPat y lo pasamos a atoms. A continuación, reviso si está vacío
    //  y llamo a la función match que recibe un ArrayList de atoms.
    public boolean match(String stringPat) {
        ArrayList<Atom> atoms = Atom.getAtoms(stringPat);
        if (atoms.isEmpty()) return false;
        return match(atoms);
    }

    private boolean match(ArrayList<Atom> atoms) {
        //  Declaro un boolean que me indicará si los carácteres harán o no match.
        boolean matches = false;
        //  Declaro un int que me indicará las posiciones que recorreremos del String text. Ya que si nos encontramos un
        // AT_START basta recorrerlo una vez.
        int finalPos = (atoms.get(0).getAtomType().equals(Atom.AtomType.AT_START) ? 1 : text.length());
        int initialPos = 0;
        Character currentTextChar;
        //  Si la posición inicial es menor que la final y la dimensión del ArrayList sea menor o igual a la resta de la dimensión del texto
        //  y la posición inicial, realizaremos los checks.
        while (initialPos < finalPos && atoms.size() <= text.length() - initialPos) {
            //  Cuando intentamos hacer match siempre pensaremos que se hace, y ya si no se puede lo cambiaremos a false.
            matches = true;
            //  Guardamos la posición en currentPos y inicio un for each que recorrerá los atoms.
            int currentPos = initialPos;
            for (Atom atom : atoms) {
                //  Guardo la posición del texto actual para poder compararla.
                currentTextChar = text.charAt(currentPos);
                //  Si el atom actual es de tipo AT_START, LIST o CHARACTER, comparamos si son iguales llamando a matches.
                //  Si se da, incremento la posición actual y nos saltamos el resto del código.
                if (atom.getAtomType().equals(Atom.AtomType.AT_START) || (atom.getAtomType().equals(Atom.AtomType.LIST)) || (atom.getAtomType().equals(Atom.AtomType.CHARACTER))) {
                    if (atom.matches(currentTextChar)) {
                        currentPos++;
                        continue;
                    }
                    //  Si no se da, cambiamos el boolean a false y salimos del bucle.
                    matches = false;
                    break;
                }
                // Si es un AT_END, revisamos si son iguales y además si están en la última posición.
                //  Si se da, salimos del código, sino también pero con el boolean en false.
                else if (atom.getAtomType().equals(Atom.AtomType.AT_END)) {
                    if (atom.matches(currentTextChar) && currentPos == text.length() - 1) {
                        break;
                    }
                    matches = false;
                    break;
                }
                //  Si el atom es de tipo ALL, basta incrementar la posición actual.
                else if (atom.getAtomType().equals(Atom.AtomType.ALL)) {
                    currentPos++;
                }
                //TODO
                else if (atom.getAtomType().equals(Atom.AtomType.CLOSURE_AST)) {
                    ArrayList<Atom> currentsAtoms = new ArrayList<>();
                    for (int i = currentPos + 1; i < atoms.size(); i++) {
                        currentsAtoms.add(atoms.get(i));
                    }
                    for (int i = 0; i < text.length(); i++) {
                        text = text.substring(currentPos);
                        Find find = new Find(text);
                    }
                }
            }
            //  Una vez fuera del bucle for each, revisamos si el boolean si es true, salimos del while, sino incrementamos la posición inicial.
            if (matches) break;
            else initialPos++;
        }
        return matches;
    }
}