package lapr.project.model;

import java.io.Serializable;
import java.math.BigInteger;
import java.util.*;
import javax.xml.parsers.*;
import lapr.project.utils.*;
import org.w3c.dom.*;

public class Utilizador implements Importable<Utilizador>, Exportable, Serializable {

    private static final String ROOT_ELEMENT_NAME = "utilizador";
    private static final String NOME_ELEMENT_NAME = "nome";
    private static final String USERNAME_ELEMENT_NAME = "username";
    private static final String PASS_ELEMENT_NAME = "password";
    private static final String EMAIL_ELEMENT_NAME = "email";
    private static final String CONFIRMADO_ELEMENT_NAME = "confirmado";
    private static final String SHIFT_ELEMENT_NAME = "shift";
    private static final String KEYWORD_ELEMENT_NAME = "keyword";

    /**
     * Variável que guarda o nome do utilizador.
     */
    private String nome;

    /**
     * Variável que guarda o username do utilizador.
     */
    private String username;

    /**
     * Variável que guarda a password do utilizador.
     */
    private String password;

    /**
     * Variável que guarda o email do utilizador.
     */
    private String email;

    /**
     * Variável que guarda a keyword do utilizador.
     */
    private String keyword;

    /**
     * Utilzzador confirmado.
     */
    private boolean confirmado;

    /**
     *
     */
    private int shift;

    /**
     * Construtor de um Utilizador sem parâmetros.
     */
    public Utilizador() {
        nome = "";
        username = "";
        email = "";
        keyword = "";
        confirmado = false;
        this.shift = (new Random()).nextInt(20) + 5;
    }

    /**
     * Método que permite modificar o nome do utilizador, recebendo o novo como
     * parâmetro.
     *
     * @param strNome novo nome
     */
    public void setNome(String strNome) {
        this.nome = strNome;
    }

    /**
     * Método que devolve a password.
     *
     * @return password
     */
    public String getPassword() {
        return this.password;
    }

    /**
     * Método que permite modificar a password do utilizador, recebendo a nova
     * como parâmetro.
     *
     * @param password nova password
     */
    public void setPassword(String password) {
        this.password = encryptPassword(password);
    }

    public String encryptPassword(String password) {
        char[] chars = password.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            chars[i] += shift;
        }
        return new String(chars);
    }

    /**
     * Método que permite modificar o email do utilizador, recebendo o novo como
     * parâmetro.
     *
     * @param strEmail novo email
     */
    public void setEmail(String strEmail) {
        this.email = strEmail;
    }

    /**
     * Método que permite modificar o username do utilizador, recebendo o novo
     * como parâmetro.
     *
     * @param username novo username
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * Método que permite modificar a keyword do utilizador, recebendo a nova
     * como parâmetro.
     *
     * @param keyword nova keyword
     */
    public void setKeyword(String keyword) {
        this.keyword = keyword;
    }

    /**
     * Método que devolve o email do utilizador.
     *
     * @return email
     */
    public String getEmail() {
        return email;
    }

    /**
     * Método que devolve o nome do utilizador.
     *
     * @return nome
     */
    public String getNome() {
        return nome;
    }

    /**
     * Método que devolve o username do utilizador.
     *
     * @return username
     */
    public String getUsername() {
        return username;
    }

    /**
     * Método que devolve a keyword do utilizador.
     *
     * @return keyword
     */
    public String getKeyword() {
        return keyword;
    }

    /**
     * Método que valida o nome, email e username do utilizador.
     *
     * @return boolean com resultado da validação
     */
    public boolean valida() {
        return validaNome() && validaEmail() && validaUsername();
    }

    /**
     * Método que valida o nome do utilizador.
     *
     * @return boolean com resultado da validação
     */
    private boolean validaNome() {
        if (nome.isEmpty()) {
            return false;
        }
        String specialChars = "\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF";
        //return nome.matches("[a-z A-Z" + specialChars + "]*");
        return nome.matches("[a-z 0-9A-Z" + specialChars + "]*");
    }

    /**
     * Método que valida o email do utilizador.
     *
     * @return boolean com resultado da validação
     */
    private boolean validaEmail() {
        if (email.isEmpty()) {
            return false;
        }
        return email.matches("(([a-z0-9!#$%&'*+-/=?^_`{|}~]+)|([a-z0-9!#$%&'*+-/=?^_`{|}~]+.[a-z0-9!#$%&'*+-/=?^_`{|}~]+))@[a-z]+([.][a-z]+)+");
    }

    /**
     * Método que valida a password do utilizador.
     *
     * @param password password do utilizador
     * @return boolean com resultado da validação
     */
    public static boolean validaPassword(String password) {
        if (password.isEmpty()) {
            return false;
        }
        return password.matches("^(?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[,.-;:])(?!.*\\s).{4,7}$");
    }

    /**
     * Método que valida o username do utilizador.
     *
     * @return boolean com resultado da validação
     */
    private boolean validaUsername() {
        if (username.isEmpty()) {
            return false;
        }
        //return username.matches("[a-zA-Z0-9_]{4,}");
        return username.matches("[a-zA-Z0-9_@.]{4,}");
    }

    /**
     * Método que compara password.
     *
     * @param password password encriptada
     * @return boolean com resultado da comparação
     */
    public boolean comparaPassword(String password) {
        String encrypted = encryptPassword(password);
        return encrypted.equals(this.password);
    }

    /**
     * Método que devolve a deslocação dos caracteres para a encriptação dos
     * dados.
     *
     * @return shift
     */
    public int getShift() {
        return shift;
    }

    /**
     * Método responsável pela encriptação do shift.
     *
     * @param i
     * @return shift encriptado
     */
    public int encryptShift(int i) {
        BigInteger num = BigInteger.valueOf(i);
        num = num.setBit(7);
        return num.intValue();
    }

    /**
     * Método que descriptografa o shift.
     *
     * @param i
     * @return shift descriptografado
     */
    public int decryptShift(int i) {
        BigInteger num = BigInteger.valueOf(i);
        num = num.clearBit(7);
        return num.intValue();
    }

    /**
     * Método que descriptografa a keyword lida por ficheiro
     *
     * @param word
     * @return keyword descriptografada
     */
    public String decrypt(String word) {
        char[] chars = word.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            chars[i] -= shift;
        }
        return new String(chars);
    }

    /**
     * Método que permite alterar a deslocação dos caracteres para a encriptação
     * dos dados.
     *
     * @param shift shift
     */
    public void setShift(int shift) {
        this.shift = shift;
    }

    /**
     * Método que permite a confirmação do utilizador.
     */
    public void confirmar() {
        this.confirmado = true;
    }

    /**
     * Método que indica que o utilizador está confirmado.
     *
     * @return confirmado
     */
    public boolean isConfirmado() {
        return confirmado;
    }

    /**
     * Método que encripta o username e o email
     *
     * @param data dados
     * @return username e email encriptados
     */
    public String encryptData(String data) {
        List<Character> alphabet = getAlphabet();
        char[] chars = data.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (chars[i] >= 'a' && chars[i] <= 'z') {
                chars[i] = alphabet.get(chars[i] - 'a');
                chars[i] += shift;
            } else if (chars[i] >= 'A' && chars[i] <= 'Z') {
                chars[i] = (char) (alphabet.get(chars[i] - 'A'));
                chars[i] -= 'a' - 'A';
                chars[i] += shift;
            } else {
                chars[i] += shift;
            }
        }
        return new String(chars);
    }

    /**
     * Método que descriptografa o username e o email.
     *
     * @param data
     * @return username e email descriptografados
     */
    public String decryptData(String data) {
        List<Character> alphabet = getAlphabet();
        char[] chars = data.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            chars[i] -= shift;
            if (chars[i] >= 'a' && chars[i] <= 'z') {
                chars[i] = (char) (alphabet.indexOf(chars[i]) + 'a');
            } else if (chars[i] >= 'A' && chars[i] <= 'Z') {
                chars[i] -= 'A';
                chars[i] = (char) (alphabet.indexOf(chars[i]));
                chars[i] += ('a' - 'A');
            }
        }
        return new String(chars);
    }

    /**
     * Método que devolve o alfabeto da encriptação.
     *
     * @return alfabeto encriptação
     */
    public List<Character> getAlphabet() {
        char[] keyChars = keyword.toCharArray();
        List<Character> list = new ArrayList<>();
        for (char c : keyChars) {
            list.add(c);
        }
        for (int i = 'a'; i <= 'z'; i++) {
            char ch = (char) i;
            if (!list.contains(ch)) {
                list.add(ch);
            }
        }
        return list;
    }

    /**
     * Método que compara usernames ou emails do utilizador.
     *
     * @param obj
     * @return boolean com resultado da comparação
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof Utilizador) {
            Utilizador ut = (Utilizador) obj;
            return ut.username.equals(this.username) || ut.email.equals(this.email);
        }
        return false;
    }

    /**
     * Método de alteração do código de hash para garantir códigos diferentes
     * para objetos diferentes.
     *
     * @return hash
     */
    @Override
    public int hashCode() {
        int hash = 7;
        hash = 79 * hash + Objects.hashCode(this.nome);
        hash = 79 * hash + Objects.hashCode(this.username);
        hash = 79 * hash + Objects.hashCode(this.password);
        hash = 79 * hash + Objects.hashCode(this.email);
        hash = 79 * hash + (this.confirmado ? 1 : 0);
        return hash;
    }

    /**
     *
     * @param id
     * @return
     */
    public boolean hasID(String id) {
        return this.getUsername().equals(id) || this.getEmail().equals(id);
    }

    /**
     * Devolve a descrição textual do utilizador.
     *
     * @return username
     */
    @Override
    public String toString() {
        return username;
    }

    /**
     * Método que apresenta a informação do utilizador.
     *
     * @return
     */
    public String getInfo() {
        StringBuilder sb = new StringBuilder();
        sb.append("Nome: ").append(nome).append("\n");
        sb.append("Username: ").append(username).append("\n");
        sb.append("Email: ").append(email).append("\n");
        return sb.toString();
    }

    /**
     * Exporta o conteúdo para um nó de XML.
     *
     * @return nó de texto contendo os dados referentes ao objeto
     */
    @Override
    public Node exportContentToXMLNode() {
        Node rootNode = null;

        try {
            DocumentBuilderFactory factory
                    = DocumentBuilderFactory.newInstance();
            //Create document builder
            DocumentBuilder builder = factory.newDocumentBuilder();

            //Obtain a new document
            Document document = builder.newDocument();

            Element elementUtilizador = document.createElement(ROOT_ELEMENT_NAME);

            Element elementNome = document.createElement(NOME_ELEMENT_NAME);
            elementNome.setTextContent(nome);
            elementUtilizador.appendChild(elementNome);

            Element elementUsername = document.createElement(USERNAME_ELEMENT_NAME);
            elementUsername.setTextContent(encryptData(username));
            elementUtilizador.appendChild(elementUsername);

            Element elementEmail = document.createElement(EMAIL_ELEMENT_NAME);
            elementEmail.setTextContent(encryptData(email));
            elementUtilizador.appendChild(elementEmail);

            Element elementConfirmado = document.createElement(CONFIRMADO_ELEMENT_NAME);
            elementConfirmado.setTextContent(Boolean.toString(confirmado));
            elementUtilizador.appendChild(elementConfirmado);

            Element elementPassword = document.createElement(PASS_ELEMENT_NAME);
            elementPassword.setTextContent(password);
            elementUtilizador.appendChild(elementPassword);

            Element elementShift = document.createElement(SHIFT_ELEMENT_NAME);
            elementShift.setTextContent(Integer.toString(encryptShift(shift)));
            elementUtilizador.appendChild(elementShift);

            Element elementKey = document.createElement(KEYWORD_ELEMENT_NAME);
            elementKey.setTextContent(encryptPassword(keyword));
            elementUtilizador.appendChild(elementKey);

            //Add root element to document
            document.appendChild(elementUtilizador);

            //It exports only the element representation to XMÇ, ommiting the XML header
            rootNode = elementUtilizador;

        } catch (ParserConfigurationException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        return rootNode;
    }

    /**
     * Importa o conteúdo de um nó de XML.
     *
     * @param node
     * @return o objeto se importar; caso contrário dá erro.
     */
    @Override
    public Utilizador importContentFromXMLNode(Node node) {
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

            //Create document builder
            DocumentBuilder builder = factory.newDocumentBuilder();

            //Obtain a new document
            Document document = builder.newDocument();
            document.appendChild(document.importNode(node, true));

            NodeList elementsUtilizador = document.getElementsByTagName(ROOT_ELEMENT_NAME);

            Node elementUtilizador = elementsUtilizador.item(0);

            this.shift = decryptShift(Integer.parseInt(elementUtilizador.getChildNodes().item(5).getTextContent()));
            this.keyword = decrypt(elementUtilizador.getChildNodes().item(6).getTextContent());
            this.nome = elementUtilizador.getChildNodes().item(0).getTextContent();
            this.username = decryptData(elementUtilizador.getChildNodes().item(1).getTextContent());
            this.email = decryptData(elementUtilizador.getChildNodes().item(2).getTextContent());
            this.confirmado = Boolean.valueOf(elementUtilizador.getChildNodes().item(3).getTextContent());
            this.password = elementUtilizador.getChildNodes().item(4).getTextContent();

        } catch (ParserConfigurationException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }

        return this;
    }

}