package ER;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import javax.swing.JOptionPane;
import javax.swing.text.html.HTMLEditorKit.Parser;

import matematica.automato.afn.AFN;
import matematica.automato.afn.Estado;
import matematica.automato.afn.buscador.Buscador;
import matematica.automato.alfabeto.Alfabeto;
import matematica.automato.transicao.FuncaoTransicao;

public class AfnMenu {

    private static final String OPCAO_INVALIDA = "Selecione uma opção válida!";

    public static void main(String[] args) {
        String operacao = "";

        do {
            operacao = JOptionPane.showInputDialog("Selecione uma opção:\n"
                    + "\t a. Definir AFN.\n"
                    + "\t b. Inserir Texto.\n"
                    + "\t c. Converter ER para AFN.\n"
                    + "\t d. Sair\n"
                    + "\t ex : a");

            if (operacao.equals("a"))
                gerarAFN();

            else if (operacao.equals("b"))
                buscarTexto();

            else if(operacao.equals("c"))
                convertErToAfn();

            else if (operacao.equals("d"))
                showMessage("Bye Bye!.\n");

            else
                showMessage(OPCAO_INVALIDA);

        } while(!operacao.equals("d"));
    }

    private static void gerarAFN() {
        List<Estado> estados = gerarEstados();
        Collection<Estado> estadosFinais = gerarEstadosFinais(estados);
        Alfabeto alfabeto = gerarAlfabeto();
        FuncaoTransicao funcaoTransicao = gerarFuncaoTransicao(estados);

        String indexEstadoInicial = JOptionPane.showInputDialog("Digite o estado inicial do autômato");
        Estado estadoInicial = estados.get(Integer.parseInt(indexEstadoInicial));

        AFN afn = new AFN(
            estados,
            alfabeto,
            funcaoTransicao,
            estadoInicial,
            estadosFinais
        );

        while (!processarString(afn).equals("b"));
    }

    private static FuncaoTransicao gerarFuncaoTransicao(List<Estado> estados) {
        FuncaoTransicao funcaoTransicao = new FuncaoTransicao();
        String operador = "";

        do {
            operador = JOptionPane.showInputDialog("Selecione uma opção:\n"
                    + "\t a. Adicionar transições.\n"
                    + "\t b. Sair.");

            if (operador.equals("a")) {
                Estado origem = estados.get(getInteger("Estado origem da transição:\n ex: 1"));
                Estado alcancavel = estados.get(getInteger("Estado alcançável da transição:\n ex: 2"));

                List<Character> simbolos = getListaSimbolos("A partir de qual/quais simbolos do alfabeto se dar essa transição?\n ex: a,b");
                for (Character simbolo : simbolos)
                    funcaoTransicao.addTransicao(origem, alcancavel, simbolo);

            } else if (operador.equals("b"))
                showMessage("Transições adicionadas\n");
            else
                showMessage(OPCAO_INVALIDA);

        } while (!operador.equals("b"));

        return funcaoTransicao;
    }

    private static int getInteger(String mensagem) {
        return Integer.parseInt(JOptionPane.showInputDialog(mensagem));
    }

    private static Alfabeto gerarAlfabeto() {
        return new Alfabeto(getListaSimbolos("digite o alfabeto:\n" + "ex: a,b"));
    }

    private static List<Character> getListaSimbolos(String mensagem) {
        List<Character> simbolos = new ArrayList<>();
        String[] alfabeto = JOptionPane.showInputDialog(mensagem).split(",");

        for (String string : alfabeto)
            simbolos.add(string.charAt(0));

        return simbolos;
    }

    private static Collection<Estado> gerarEstadosFinais(List<Estado> estados) {
        Collection<Estado> estadosFinais = new ArrayList<>();
        String[] indexEstadosFinais = JOptionPane.showInputDialog("indique os estados finais:\nex:0,1\n (correspondendo a q0 e q1)").split(",");

        for (String index : indexEstadosFinais)
            estadosFinais.add(estados.get(Integer.parseInt(index)));

        return estadosFinais;
    }

    private static void showMessage(String message) {
        JOptionPane.showMessageDialog(null, message);
    }

    private static String processarString(AFN afn) {
        String operacao;

        operacao = JOptionPane.showInputDialog("Selecione uma opção:\n"
                + "\t a.processar String.\n"
                + "\t b.sair.");

        if (operacao.equals("a")) {
            String processar = JOptionPane.showInputDialog("digite a string que será processada!");

            if (afn.aceita(processar))
                JOptionPane.showMessageDialog(null, "String '"+processar+ "' foi aceita pelo automato");
            else
                JOptionPane.showMessageDialog(null, "String '"+processar+ "' não foi aceita pelo automato");

        } else if (operacao.equals("b"))
            JOptionPane.showMessageDialog(null, "Bye Bye!.\n");
        else
            showMessage(OPCAO_INVALIDA);

        return operacao;
    }

    public static List<Estado> gerarEstados() {
        int numeroEstados = Integer.parseInt(JOptionPane.showInputDialog(null,  "Digite o numero de estados da AFN: \n\n"
                + "OBS: A CONTAGEM DOS ESTADOS COMEÇA DO ZERO \n ex : 5 -> ESTADOS DE q0 A q4"));

        List<Estado> estados = new ArrayList<>();
        for (int i=0; i<numeroEstados; i++)
            estados.add(new Estado(i));

        return estados;
    }

    private static void buscarTexto() {
        String texto = JOptionPane.showInputDialog("Digite o texto");
        String operacao = "";

        do {
            operacao = JOptionPane.showInputDialog("Selecione uma opção:\n"
                    + "\t a. Buscar texto.\n"
                    + "\t b. Voltar");

            if (operacao.equals("a")) {
                String parte = JOptionPane.showInputDialog("Digite o texto que será buscada!");

                if (Buscador.buscar(texto, parte))
                    showMessage("'"+parte+ "' localizada no texto!");
                else
                    showMessage("'"+parte+ "' não localizada no texto");

            } else if(operacao.equals("b"))
                showMessage("Bye Bye!.\n");
            else
                showMessage(OPCAO_INVALIDA);


        } while(!operacao.equals("b"));
    }
    private static void convertErToAfn(){
        String expressaoRegularBruta = JOptionPane.showInputDialog("Digite a expressão regular para ser convertida");
        ConvertToAFN oConvert = new ConvertToAFN(expressaoRegularBruta);
        List<String> resultado = oConvert.toAFDe();
        Collection<Estado> estadoInicial = new ArrayList<>();
        Collection<Estado> estados = new ArrayList<>();
        Collection<Estado> estadosFinais = new ArrayList<>();

        geraEstados(resultado,estadoInicial,estados,estadosFinais);

    }

    private static void geraEstados(List resultado, Collection<Estado> estadoInicial, Collection<Estado> estados, Collection<Estado> estadosFinais){

        for (int i = 1; i<resultado.size();i++) {
            boolean estadoFinal = false;
            String numeroEstado="";
            for(int j=0;j<resultado.get(i).toString().length();j++){
                    if(resultado.get(i).toString().charAt(j) == '*'){
                        estadoFinal = true;
                    }else if(verificaCaractereNumero(resultado.get(i).toString().charAt(j))){
                        numeroEstado +=resultado.get(i).toString().charAt(j);

                    }else if(resultado.get(i).toString().charAt(j) == '-'){
                        break;
                    }

            }
            //System.out.println(numeroEstado);
            if(numeroEstado.equals("0")){
                Estado estado = new Estado(Integer.parseInt(numeroEstado));
                estadoInicial = Estado.estados(estado);
                //estadoInicial = Estado.estados(new Estado(Integer.parseInt(numeroEstado)));
                //estadoInicial = (Collection<Estado>) new Estado(Integer.parseInt(numeroEstado));
                //System.out.println(numeroEstado);
            }else if(estadoFinal){
                Estado estado = new Estado(Integer.parseInt(numeroEstado));
                estadosFinais = Estado.estados(estado);
                //estadosFinais = Estado.estados(new Estado(Integer.parseInt(numeroEstado)));
                //System.out.println(numeroEstado);
            }

            if(!numeroEstado.equals("0")){
                estados = Estado.estados(new Estado(Integer.parseInt(numeroEstado)));
                //System.out.println(numeroEstado);
            }
            System.out.println(estadosFinais.size());
            //System.out.println(estadoFinal);
            //System.out.println(Integer.parseInt(numeroEstado));
            //System.out.println(resultado.get(i).toString().charAt(0));
            //System.out.println(resultado.get(i));
        }

        //new AFN(estados, new Alfabeto('a', 'b'), new FuncaoTransicao(), estadoInicial, estadosFinais);

    }

    private static boolean verificaCaractereNumero(char c){

        if(c == '0' || c=='1' || c=='2' || c =='3' || c =='4' || c =='5' || c =='6' || c =='7' || c =='8' || c =='9'){
            return  true;
        }else{
            return false;
        }

    }

}