package ru.mobileup.tutu.mvp.main.order.passengers.details;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import ru.mobileup.tutu.core.core.PassengerDocumentType;
import ru.mobileup.tutu.entity.Passenger;
import ru.mobileup.tutu.mvp.main.order.passengers.details.PassengerDetailsContract.ValidationErrorType;

import static ru.mobileup.tutu.core.core.PassengerDocumentType.EMPTY;
import static ru.mobileup.tutu.core.core.PassengerDocumentType.FOREIGN_DOCUMENT;

public class PassengerValidationUtil {

    public static final String DOMESTIC_COUNTRY_CODE = "RUS";
    public static final List<PassengerDocumentType> NON_DOMESTIC_DOC_TYPES = new ArrayList<PassengerDocumentType>() {{
        add(FOREIGN_DOCUMENT);
    }};

    public static final Long INVALID_DATE = Long.MIN_VALUE;

    private static final String LATIN_CHARS = "qwertyuiopasdfghjklzxcvbnm";
    private static final String MIDDLE_NAME = "отчество";
    private static final String CYRILIC_LIKE_CHARS = "cmtbapokehx";
    private static final String CYRILIC_CHARS = "йцукенгшщзхъфывапролджэячсмитьбю";

    public static Set<ValidationErrorType> validate(Passenger passenger) {
        Set<ValidationErrorType> errors = new HashSet<>();

        errors.addAll(basicChecks(passenger));
        errors.addAll(documentChecks(passenger));
        errors.addAll(birthDateChecks(passenger));
        errors.addAll(citizenshipChecks(passenger));

        return errors;
    }

    private static Set<ValidationErrorType> basicChecks(Passenger passenger) {
        Set<ValidationErrorType> errors = new HashSet<>();

        String firstName = passenger.getFirstName();
        String lastName = passenger.getLastName();
        String middleName = passenger.getMiddleName();

        if (lastName == null || lastName.trim().isEmpty() || lastName.length() > 40 || !hasLetter(lastName)) {
            errors.add(ValidationErrorType.LAST_NAME_ERROR);
        }

        if (firstName == null || firstName.trim().isEmpty() || firstName.length() > 20 || !hasLetter(firstName)) {
            errors.add(ValidationErrorType.FIRST_NAME_ERROR);
        }

        if (middleName != null) {
            if (middleName.trim().length() > 20) {
                errors.add(ValidationErrorType.MIDDLE_NAME_ERROR);
            }

            if (middleName.trim().toLowerCase().equals(MIDDLE_NAME)) {
                errors.add(ValidationErrorType.MIDDLE_NAME_ERROR);
            }

            if (!middleName.trim().isEmpty()) {
                if (!hasLetter(middleName) && !middleName.trim().equals("-")) {
                    errors.add(ValidationErrorType.MIDDLE_NAME_ERROR);
                }
            }
        }

        int firstNameLenght = firstName == null ? 0 : firstName.trim().length();
        int lastNameLenght = lastName == null ? 0 : lastName.trim().length();
        int middleNameLenght = middleName == null ? 0 : middleName.trim().length();

        if (firstNameLenght + lastNameLenght + middleNameLenght > 73) {
            errors.add(ValidationErrorType.LAST_NAME_ERROR);
        }

        return errors;
    }

    private static Set<ValidationErrorType> documentChecks(Passenger passenger) {
        Set<ValidationErrorType> errors = new HashSet<>();

        String number = passenger.getDocumentNumber();

        if (passenger.getDocumentType() != null) {
            if (passenger.getDocumentType() != EMPTY && (number == null || number.trim().isEmpty())) {
                errors.add(ValidationErrorType.DOCUMENT_NUMBER_EMPTY_ERROR);
            } else {
                switch (passenger.getDocumentType()) {
                    case INNER_PASSPORT:
                        errors.addAll(checkNameForLatinLetters(passenger));
                        if (!isInnerPassportNumberValid(number)) {
                            errors.add(ValidationErrorType.DOCUMENT_NUMBER_ERROR);
                        }
                        break;
                    case BIRTH_CERTIFICATE:
                        errors.addAll(checkNameForLatinLetters(passenger));
                        if (!isBithCertificateNumberFormatValid(number)) {
                            errors.add(ValidationErrorType.DOCUMENT_NUMBER_ERROR);
                        }
                        break;
                    case SAILOR_DOC:
                        errors.addAll(checkNameForLatinLetters(passenger));
                        if (!isSailorDocNumberValid(number)) {
                            errors.add(ValidationErrorType.DOCUMENT_NUMBER_ERROR);
                        }
                        break;
                    case MILITARY_DOC:
                        errors.addAll(checkNameForLatinLetters(passenger));
                        if (!isMilitaryDocNumberValid(number)) {
                            errors.add(ValidationErrorType.DOCUMENT_NUMBER_ERROR);
                        }
                        break;
                    case OUTER_PASSPORT:
                        if (!isOuterPassportNumberValid(number)) {
                            errors.add(ValidationErrorType.DOCUMENT_NUMBER_ERROR);
                        }
                        break;
                    case FOREIGN_DOCUMENT:
                        if (!isForeignPassportNumberValid(number)) {
                            errors.add(ValidationErrorType.DOCUMENT_NUMBER_ERROR);
                        }
                        break;
                    case EMPTY:
                        if (number != null && !number.trim().isEmpty()) {
                            errors.add(ValidationErrorType.DOCUMENT_NUMBER_ERROR);
                        }
                        break;
                }
            }
        } else {
            if (number != null && !number.trim().isEmpty()) {
                errors.add(ValidationErrorType.DOCUMENT_TYPE_ERROR);
            }
        }

        return errors;
    }

    private static Set<ValidationErrorType> birthDateChecks(Passenger passenger) {
        Set<ValidationErrorType> errors = new HashSet<>();

        Long birthday = passenger.getBirthday();
        if (birthday != null) {
            if (birthday.equals(INVALID_DATE)) { // format error
                errors.add(ValidationErrorType.BIRTHDAY_ERROR);
            }

            if (birthday > System.currentTimeMillis()) {
                errors.add(ValidationErrorType.BIRTHDAY_ERROR);
            }

            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.YEAR, 1900);
            calendar.set(Calendar.MONTH, Calendar.JANUARY);
            calendar.set(Calendar.DAY_OF_YEAR, 1);

            if (birthday < calendar.getTimeInMillis()) {
                errors.add(ValidationErrorType.BIRTHDAY_ERROR);
            }
        }
        return errors;
    }

    private static Set<ValidationErrorType> citizenshipChecks(Passenger passenger) {
        Set<ValidationErrorType> errors = new HashSet<>();

        String citizenship = passenger.getCitizenship();
        PassengerDocumentType documentType = passenger.getDocumentType();

        if (DOMESTIC_COUNTRY_CODE.equals(citizenship) && NON_DOMESTIC_DOC_TYPES.contains(documentType)) {
            errors.add(ValidationErrorType.CITIZENSHIP_ERROR);
        } else if ((documentType == null || documentType == EMPTY) && citizenship != null) {
            errors.add(ValidationErrorType.CITIZENSHIP_ERROR);
        }
        return errors;
    }

    private static Set<ValidationErrorType> checkNameForLatinLetters(Passenger passenger) {
        Set<ValidationErrorType> errors = new HashSet<>();

        if (passenger.getFirstName() != null && hasLatinLetters(passenger.getFirstName())) {
            errors.add(ValidationErrorType.FIRST_NAME_ERROR);
        }
        if (passenger.getLastName() != null && hasLatinLetters(passenger.getLastName())) {
            errors.add(ValidationErrorType.LAST_NAME_ERROR);
        }

        if (passenger.getMiddleName() != null && hasLatinLetters(passenger.getMiddleName())) {
            errors.add(ValidationErrorType.MIDDLE_NAME_ERROR);
        }
        return errors;
    }

    private static boolean hasLetter(String string) {
        for (char next : string.toCharArray()) {
            if (Character.isLetter(next)) {
                return true;
            }
        }
        return false;
    }

    private static boolean hasLatinLetters(String name) {
        String lowerCaseName = name.toLowerCase();
        for (char c : LATIN_CHARS.toCharArray()) {
            if (lowerCaseName.contains(String.valueOf(c))) {
                return true;
            }
        }
        return false;
    }

    private static boolean digitsOnly(String string) {
        for (char c : string.toCharArray()) {
            if (!Character.isDigit(c)) {
                return false;
            }
        }
        return true;
    }

    private static boolean cyrilicLikeCharsOnly(String string) {
        for (char c : string.toLowerCase().toCharArray()) {
            String character = Character.toString(c);
            if (!CYRILIC_CHARS.contains(character) && !CYRILIC_LIKE_CHARS.contains(character)) {
                return false;
            }
        }
        return true;
    }

    private static boolean isInnerPassportNumberValid(String string) {
        if (string != null) {
            string = string.replaceAll("[ \\-]", "");

            if (string.length() != 10 || !digitsOnly(string)) {
                return false;
            }
        } else {
            return false;
        }
        return true;
    }

    private static boolean isBithCertificateNumberFormatValid(String string) {
        if (string != null) {
            string = string.replaceAll("[№ \\-]", "");

            if (string.length() < 9) {
                return false;
            }
            String firstToken = string.substring(0, string.length() - 8).toUpperCase();
            String secondToken = string.substring(string.length() - 8, string.length() - 6).toUpperCase();
            String thirdToken = string.substring(string.length() - 6, string.length()).toUpperCase();

            if (!firstToken.replaceAll("[IVX]", "").isEmpty() || romanToDecimal(firstToken) > 35) {
                return false;
            }

            if (!cyrilicLikeCharsOnly(secondToken)) {
                return false;
            }

            return digitsOnly(thirdToken);
        } else {
            return false;
        }
    }

    private static int romanToDecimal(java.lang.String romanNumber) {
        int decimal = 0;
        int lastNumber = 0;
        String romanNumeral = romanNumber.toUpperCase();

        for (int x = romanNumeral.length() - 1; x >= 0; x--) {
            char convertToDecimal = romanNumeral.charAt(x);

            switch (convertToDecimal) {
                case 'X':
                    decimal = processDecimal(10, lastNumber, decimal);
                    lastNumber = 10;
                    break;

                case 'V':
                    decimal = processDecimal(5, lastNumber, decimal);
                    lastNumber = 5;
                    break;

                case 'I':
                    decimal = processDecimal(1, lastNumber, decimal);
                    lastNumber = 1;
                    break;

                default:
                    return Integer.MAX_VALUE;
            }
        }
        return decimal;
    }

    private static int processDecimal(int decimal, int lastNumber, int lastDecimal) {
        if (lastNumber > decimal) {
            return lastDecimal - decimal;
        } else {
            return lastDecimal + decimal;
        }
    }

    private static boolean isSailorDocNumberValid(String string) {
        if (string != null) {
            string = string.replaceAll("[ \\-]", "").toLowerCase();

            if (string.length() != 9) {
                return false;
            }

            boolean digitsStarted = false;
            for (int i = 0; i < string.length(); i++) {
                if (Character.isLetter(string.charAt(i))) {
                    if (i >= 2 || digitsStarted) {
                        return false;
                    }
                } else if (Character.isDigit(string.charAt(i))) {
                    if (!digitsStarted) {
                        digitsStarted = true;
                    }
                } else {
                    return false;
                }
            }
            return true;
        } else {
            return false;
        }
    }

    private static boolean isMilitaryDocNumberValid(String string) {
        if (string != null) {
            for (char c : string.toCharArray()) {
                if (Character.isDigit(c)) {
                    return true;
                }
            }
            return false;
        } else {
            return false;
        }
    }

    private static boolean isOuterPassportNumberValid(String string) {
        if (string != null) {
            string = string.replaceAll("[ \\-]", "");
            if (string.length() != 9) {
                return false;
            }

            for (char c : string.toCharArray()) {
                if (!Character.isDigit(c)) {
                    return false;
                }
            }
            return true;
        } else {
            return false;
        }
    }

    private static boolean isForeignPassportNumberValid(String string) {
        if (string != null) {
            string = string.replaceAll("[ \\-]", "");

            return string.length() <= 16;
        } else {
            return false;
        }
    }

}