import Foundation

// MARK: - EmailValidationError

enum EmailValidationError: Error {
    case empty
    case invalidFormat
}

// MARK: - PasswordValidationError

enum PasswordValidationError: Error {
    case empty
    case tooShort
    case noUppercaseLetter
    case noLowercaseLetter
    case noNumber
}

// MARK: - Validators

struct EmptyStringValidator: Validator {
    private let invalidError: Error

    init(invalidError: Error) {
        self.invalidError = invalidError
    }

    func validate(_ value: String) -> ValidationResult {
        if value.isEmpty {
            return .invalid(errors: [invalidError])
        } else {
            return .valid
        }
    }
}

struct EmailFormatValidator: Validator {
    func validate(_ value: String) -> ValidationResult {
        let magicEmailRegexStolenFromTheInternet = "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$"
        let emailTest = NSPredicate(format:"SELF MATCHES %@", magicEmailRegexStolenFromTheInternet)
        if emailTest.evaluate(with: value) {
            return .valid
        } else {
            return .invalid(errors: [EmailValidationError.invalidFormat])
        }
    }
}

struct PasswordLengthValidator: Validator {
    func validate(_ value: String) -> ValidationResult {
        if value.characters.count >= 8 {
            return .valid
        } else {
            return .invalid(errors: [PasswordValidationError.tooShort])
        }
    }
}

struct UppercaseLetterValidator: Validator {
    func validate(_ value: String) -> ValidationResult {
        let uppercaseLetterRegex = ".*[A-Z]+.*"
        let uppercaseLetterTest = NSPredicate(format:"SELF MATCHES %@", uppercaseLetterRegex)
        if uppercaseLetterTest.evaluate(with: value) {
            return .valid
        } else {
            return .invalid(errors: [PasswordValidationError.noUppercaseLetter])
        }
    }
}

// MARK: - ValidatorFactory

struct ValidatorFactory {
    static let sharedInstance = ValidatorFactory()
    private init() {}

    func emailValidator() -> Validator {
        return CompositeValidator(validators: emptyEmailStringValidator(), EmailFormatValidator())
    }

    func passwordValidator() -> Validator {
        return CompositeValidator(validators: emptyPasswordStringValidator(), passwordStrengthValidator())
    }

    private func emptyEmailStringValidator() -> Validator {
        return EmptyStringValidator(invalidError: EmailValidationError.empty)
    }

    private func emptyPasswordStringValidator() -> Validator {
        return EmptyStringValidator(invalidError: PasswordValidationError.empty)
    }

    private func passwordStrengthValidator() -> Validator {
        return CompositeValidator(validators: PasswordLengthValidator(), UppercaseLetterValidator())
    }
}

// MARK: - Exectute

let emailValidator = ValidatorFactory.sharedInstance.emailValidator()
print(emailValidator.validate(""))
print(emailValidator.validate("invalidEmail@"))
print(emailValidator.validate("validEmail@validDomain.com"))

let passwordValidator = ValidatorFactory.sharedInstance.passwordValidator()
print(passwordValidator.validate(""))
print(passwordValidator.validate("psS$"))
print(passwordValidator.validate("paSSw0rd"))