package pt.ipleiria.estg.dei.contacts.model;

import java.util.LinkedList;

import pt.ipleiria.estg.dei.colecoes.ComparacaoLimite;
import pt.ipleiria.estg.dei.colecoes.Iterador;
import pt.ipleiria.estg.dei.colecoes.ListaSimplesCircularBaseLimite;
import pt.ipleiria.estg.dei.colecoes.TabelaHashPorListas;
import pt.ipleiria.estg.dei.colecoes.TabelaHashPorSondagem;
import pt.ipleiria.estg.dei.colecoes.TabelaHashPorSondagemHashingDuplo;
import pt.ipleiria.estg.dei.contacts.R;
import pt.ipleiria.estg.dei.contacts.colections.Filtro;
import pt.ipleiria.estg.dei.contacts.colections.ListaSimplesCircularBaseLimiteFiltravel;
import pt.ipleiria.estg.dei.contacts.exceptions.EmailExistsException;
import pt.ipleiria.estg.dei.contacts.exceptions.IdExistsException;

import static android.R.attr.order;


public enum ContactManager {
    INSTANCE;

    public enum OrderBy {
        ID_ASC(CompareContactIdsByAscendingOrder.INSTANCE),
        NAME_DESC(CompareContactNamesByDescendingOrder.INSTANCE);

        public final ComparacaoLimite<Contact> COMPARATOR;

        OrderBy(ComparacaoLimite<Contact> comparator) {
            this.COMPARATOR = comparator;
        }
    }


    private ListaSimplesCircularBaseLimiteFiltravel<Contact>[] contacts;


    private TabelaHashPorListas<Long, Contact> HashContactsById;

    private TabelaHashPorSondagemHashingDuplo<String, Contact> HashSondagemDuplaContactsByEmail;

    private TabelaHashPorSondagemHashingDuplo<String, ListaSimplesCircularBaseLimite<Contact>> hashContactByDomain;

    ContactManager() {
        contacts = new ListaSimplesCircularBaseLimiteFiltravel[OrderBy.values().length];

        for (OrderBy order : OrderBy.values()) {
            contacts[order.ordinal()] =
                    new ListaSimplesCircularBaseLimiteFiltravel<Contact>(order.COMPARATOR);
        }

        HashContactsById = new TabelaHashPorListas<>(1000, HashingLongs.INSTANCE, CompareLongAsc.INSTANCE);

        HashSondagemDuplaContactsByEmail = new TabelaHashPorSondagemHashingDuplo<>(1000, HashingStrings.INSTANCE, new HashingIncrStrings(1000));

        hashContactByDomain = new TabelaHashPorSondagemHashingDuplo<>(1000, HashingStrings.INSTANCE, new HashingIncrStrings(1000));
        addExampleContacts();
    }

        public Iterador<Contact> getByDomain(String domain) {
            ListaSimplesCircularBaseLimite<Contact> lista = hashContactByDomain.consultar(domain);

            if (lista != null) {
                return lista.iterador();
            }
            return new ListaSimplesCircularBaseLimite<>(CompareContactEmailsByAscendingOrder.INSTANCE).iterador();
        }
    private void addExampleContacts() {
        add(new Contact(12345, "Carlos Urbano", 1973, "curbano@gmail.com"));
        add(new Contact(65432, "Ana Silva", 1981, "asilva@hotmail.com"));
        add(new Contact(56462, "Joaquim Correia", 2000, "jcorreia@gmail.com"));
        add(new Contact(43526, "Anibal Pereira", 2000, "apereira@gmail.com"));
        add(new Contact(21342, "Manuel José", 1973, "mjose@gmail.com"));
        add(new Contact(67848, "Maria Joaquina", 2000, "mjoaquina@hotmail.com"));
        add(new Contact(84753, "Daniela Alves", 1981, "dalves@gmail.com"));
    }

    public void add(Contact c) {

        //Comparar ID inserido com uma já existente
        final Contact iDexistente = getById(c.getId());

        final Contact emailExistente = getByEmail(c.getEmail());


        if (iDexistente != null) {
            throw new IdExistsException();
        } else if (emailExistente != null) {
            throw new EmailExistsException();
        }

        for (OrderBy order : OrderBy.values()) {
            contacts[order.ordinal()].inserir(c);
        }
        HashContactsById.inserir(c.getId(), c);
        HashSondagemDuplaContactsByEmail.inserir(c.getEmail(), c);

        addToHashByDomain(c);
    }

    private void addToHashByDomain(Contact c) {
        ListaSimplesCircularBaseLimite<Contact> lista = hashContactByDomain.consultar(c.getEmailDomain());

        if (lista == null) {
            lista = new ListaSimplesCircularBaseLimite<Contact>(CompareContactEmailsByAscendingOrder.INSTANCE);
            hashContactByDomain.inserir(c.getEmailDomain(), lista);
        }
        lista.inserir(c);
    }

    public void remove(Contact c) {
        for (OrderBy order : OrderBy.values()) {
            contacts[order.ordinal()].remover(c);
        }
        HashContactsById.remover(c.getId());
        HashSondagemDuplaContactsByEmail.remover(c.getEmail());

        removeFromHashByDomain(c);


    }

    private void removeFromHashByDomain(Contact c) {
        ListaSimplesCircularBaseLimite<Contact> lista = hashContactByDomain.consultar(c.getEmailDomain());

        if (lista != null) {
            lista.remover(c);
            if (lista.isVazia()) {
                hashContactByDomain.remover(c.getEmailDomain());
            }
        }
    }

    public Contact get(OrderBy order, int index) {
        return contacts[order.ordinal()].consultar(index);
    }

    public Contact getById(long id) {
        return HashContactsById.consultar(id);
//        Iterador<Contact> it = contacts[OrderBy.ID_ASC.ordinal()].consultar(new Contact(id, "", 0, ""));
//        if (it.podeAvancar())
//            return it.avancar();
//        return null;
    }

    public Contact getByEmail(String email) {

        return HashSondagemDuplaContactsByEmail.consultar(email);
//        Iterador<Contact> it = contacts[OrderBy.EMAIL_ASC.ordinal()].consultar(new Contact(0,"",0,email));
//        if (it.podeAvancar()){
//            return  it.avancar();
//        }
//        return null;
    }

    public Iterable<Contact> getAll(OrderBy order) {
        return contacts[order.ordinal()];
    }

    public Iterador<Long> getAllIDs() {
        return HashContactsById.iteradorChaves();
    }

    public Iterador<String> getAllDomains() {
        return hashContactByDomain.iteradorChaves();
    }

    @Override
    public String toString() {
        StringBuilder result = new StringBuilder("");

        for (OrderBy order : OrderBy.values()) {
            result.append("=========== ").append(order).append("\n");
            for (Contact c : contacts[order.ordinal()]) {
                result.append(c.toString()).append("---------------\n");
            }
        }

        return result.toString();
    }

    public void update(Contact oldContact, Contact newContact) {

        if (oldContact != null) {

            //Ou nao estou a alterar ID
            //OU ESTOU A ALTERAR ID
            //      JA EXISTE UM CONTACTO COM ESSE ID === ERRO
            //      OU NAO EXISTE CONTACTO COM ESSE ID


            if (oldContact.getId() != newContact.getId() && getById(newContact.getId()) != null) {
                throw new IdExistsException();
            } else if (!oldContact.getEmail().equals(newContact.getEmail()) && getByEmail(newContact.getEmail()) != null) {
                throw new EmailExistsException();
            }

//            boolean altereiID = false;
//            if (oldContact.getId() != newContact.getId()) {
//                HashContactsById.remover(oldContact.getId());
//                altereiID = true;
//            }

            HashContactsById.remover(oldContact.getId());
            HashSondagemDuplaContactsByEmail.remover(oldContact.getEmail());

            LinkedList<Integer> listasOndeRemovi = new LinkedList<>();
            for (OrderBy order : OrderBy.values()) {
                if (order.COMPARATOR.comparar(oldContact, newContact) != 0) {
                    contacts[order.ordinal()].removerPorReferencia(oldContact);
                    listasOndeRemovi.add(order.ordinal());
                }
            }

            oldContact.copyFrom(newContact);

            for (Integer i : listasOndeRemovi) {
                contacts[i].inserir(oldContact);
            }

//            if (altereiID) {
//                HashContactsById.inserir(oldContact.getId(),oldContact);
//            }

            HashContactsById.inserir(oldContact.getId(), oldContact);
            HashSondagemDuplaContactsByEmail.inserir(oldContact.getEmail(), oldContact);

            addToHashByDomain(oldContact);

        }
    }

    public void filterBy(Filtro<Contact> filtro) {
        for (OrderBy order : OrderBy.values()) {
            contacts[order.ordinal()].setFiltro(filtro);
        }
    }


}