<?php

namespace bff\validation;

use Closure;

/**
 * Has rules trait
 * @copyright Tamaranga
 */
trait HasRules
{
    /**
     * Add one rule
     * @param mixed|Rule $rule
     * @param array|mixed $opts
     * @return static|Rule
     */
    abstract public function rule($rule, $opts = []);

    /**
     * Accepted validation rule
     * @param array $opts [allowed]
     * @return static
     */
    public function ruleAccepted(array $opts = [])
    {
        return $this->rule('accepted', $opts);
    }

    /**
     * Beetween validation rule
     * @param int $min
     * @param int $max
     * @param array $opts
     * @return static
     */
    public function ruleBeetween($min, $max, array $opts = [])
    {
        $opts['min'] = $min;
        $opts['max'] = $max;
        return $this->rule('beetween', $opts);
    }

    /**
     * Callback validation rule
     * @param Closure $callback
     * @param array $opts
     * @return static
     */
    public function ruleCallback(Closure $callback, array $opts = [])
    {
        $opts['callback'] = $callback;
        return $this->rule('callback', $opts);
    }

    /**
     * Date validation rule
     * @param string $format date format
     * @param array $opts
     * @return static
     */
    public function ruleDate($format = 'Y-m-d', array $opts = [])
    {
        $opts['format'] = $format;
        return $this->rule('date', $opts);
    }

    /**
     * Email validation rule
     * @param array $opts [format]
     * @return static
     */
    public function ruleEmail(array $opts = [])
    {
        return $this->rule('email', $opts);
    }

    /**
     * In rule
     * @param array|Closure $allowed list of allowed values (closure returning list)
     * @param bool $strict strict compare
     * @param array $opts
     * @return static
     */
    public function ruleIn($allowed, $strict = false, array $opts = [])
    {
        $opts['allowed'] = $allowed;
        $opts['strict'] = $strict;
        return $this->rule('in', $opts);
    }

    /**
     * Not In rule
     * @param array|Closure $allowed list of not allowed values (closure returning list)
     * @param bool $strict strict compare
     * @param array $opts
     * @return static
     */
    public function ruleNotIn($allowed, $strict = false, array $opts = [])
    {
        $opts['not'] = true;
        return $this->ruleIn($allowed, $strict, $opts);
    }

    /**
     * Ip address validation rule
     * @param array $opts
     * @return static
     */
    public function ruleIp(array $opts = [])
    {
        return $this->rule('ip', $opts);
    }

    /**
     * Array validation rule
     * @param array $opts
     * @return static
     */
    public function ruleArray(array $opts = [])
    {
        return $this->rule('array', $opts);
    }

    /**
     * Integer validation rule
     * @param array $opts
     * @return static
     */
    public function ruleInteger(array $opts = [])
    {
        return $this->rule('integer', $opts);
    }

    /**
     * Numeric validation rule
     * @param array $opts
     * @return static
     */
    public function ruleNumeric(array $opts = [])
    {
        return $this->rule('numeric', $opts);
    }

    /**
     * String validation rule
     * @param int $max length limit
     * @param int $min min length
     * @param array $opts
     * @return static
     */
    public function ruleString($max = 0, $min = 0, array $opts = [])
    {
        if ($max > 0) {
            $opts['max'] = $max;
        }
        if ($min > 0) {
            $opts['min'] = $min;
        }
        return $this->rule('string', $opts);
    }

    /**
     * JSON rule
     * @param array $opts
     * @return static
     */
    public function ruleJson(array $opts = [])
    {
        return $this->rule('json', $opts);
    }

    /**
     * Maximum validation rule
     * @param int $max
     * @param array $opts
     * @return static
     */
    public function ruleMax($max, array $opts = [])
    {
        $opts['max'] = $max;
        return $this->rule('max', $opts);
    }

    /**
     * Minimum validation rule
     * @param int $min
     * @param array $opts
     * @return static
     */
    public function ruleMin($min, array $opts = [])
    {
        $opts['min'] = $min;
        return $this->rule('min', $opts);
    }

    /**
     * Password validation rule
     * @param array $opts [min, max, noSpaces, noTags, noUrl]
     * @return static
     */
    public function rulePassword(array $opts = [])
    {
        return $this->rule('password', $opts);
    }

    /**
     * Phone number validation rule
     * @param array $opts [min, max, pattern, codeFilter]
     * @return static
     */
    public function rulePhone(array $opts = [])
    {
        return $this->rule('phone', $opts);
    }

    /**
     * Regular expression validation rule
     * @param string $pattern
     * @param bool $not invert comparison
     * @param array $opts
     * @return static
     */
    public function ruleRegexp($pattern, $not = false, array $opts = [])
    {
        $opts['pattern'] = $pattern;
        $opts['not'] = $not;
        return $this->rule('regexp', $opts);
    }

    /**
     * Required validation rule
     * @param bool|Closure $not true -> optional
     * @param array $opts
     * @return static
     */
    public function ruleRequired($not = false, array $opts = [])
    {
        if ($not === true) {
            $opts['not'] = true;
        } elseif ($not instanceof Closure) {
            $opts['callback'] = $not;
        }
        return $this->rule('required', $opts);
    }

    /**
     * Uuid validation rule
     * @param array $opts
     * @return static
     */
    public function ruleUuid(array $opts = [])
    {
        return $this->rule('uuid', $opts);
    }

    /**
     * Version number validation rule
     * @param array $opts [min, max]
     * @return static
     */
    public function ruleVersion(array $opts = [])
    {
        return $this->rule('version', $opts);
    }
}