<?php

namespace Give\Framework\Models;

use Give\Framework\Exceptions\Primitives\InvalidArgumentException;
use Give\Framework\Models\ValueObjects\Relationship;
use Give\Framework\Support\Contracts\Arrayable;
use RuntimeException;

/**
 * @since 2.19.6
 */
abstract class Model implements Arrayable
{
    /**
     * The model's attributes.
     *
     * @var array
     */
    protected $attributes = [];

    /**
     * The model attribute's original state.
     *
     * @var array
     */
    protected $original = [];

    /**
     * The model properties assigned to their types
     *
     * @var array
     */
    protected $properties = [];

    /**
     * The model relationships assigned to their relationship types
     *
     * @var array
     */
    protected $relationships = [];

    /**
     * Relationships that have already been loaded and don't need to be loaded again.
     *
     * @var Model[]
     */
    private $cachedRelations = [];

    /**
     * Create a new model instance.
     *
     * @since      2.19.6
     * @since      2.20.0 add support for property defaults
     * @since 2.23.1 Make constructor final to avoid unsafe usage of `new static()`.
     *
     * @param array $attributes
     *
     * @return void
     */
    final public function __construct(array $attributes = [])
    {
        $this->fill(array_merge($this->getPropertyDefaults(), $attributes));

        $this->syncOriginal();
    }

    /**
     * Sync the original attributes with the current.
     *
     * @since 2.19.6
     *
     * @return $this
     */
    protected function syncOriginal()
    {
        $this->original = $this->attributes;

        return $this;
    }

    /**
     * Get the model's original attribute values.
     *
     * @since 2.19.6
     *
     * @param string|null $key
     *
     * @return mixed|array
     */
    public function getOriginal($key = null)
    {
        return $key ? $this->original[$key] : $this->original;
    }

    /**
     * Determine if a given attribute is dirty.
     *
     * @since 2.19.6
     *
     * @param string|null $attribute
     *
     * @return bool
     */
    public function isDirty($attribute = null)
    {
        if ( ! $attribute) {
            return (bool)$this->getDirty();
        }

        return array_key_exists($attribute, $this->getDirty());
    }

    /**
     * Determine if a given attribute is clean.
     *
     * @since 2.19.6
     *
     * @param string|null $attribute
     *
     * @return bool
     */
    public function isClean($attribute = null)
    {
        return ! $this->isDirty($attribute);
    }

    /**
     * Get the attributes that have been changed since last sync.
     *
     * @since 2.19.6
     *
     * @return array
     */
    public function getDirty()
    {
        $dirty = [];

        foreach ($this->attributes as $key => $value) {
            if ( ! array_key_exists($key, $this->original) || $value !== $this->original[$key]) {
                $dirty[$key] = $value;
            }
        }

        return $dirty;
    }

    /**
     * Fill the model with an array of attributes.
     *
     * @since 2.19.6
     *
     * @param array $attributes
     *
     * @return $this
     */
    public function fill(array $attributes)
    {
        foreach ($attributes as $key => $value) {
            $this->setAttribute($key, $value);
        }

        return $this;
    }

    /**
     * Get an attribute from the model.
     *
     * @since 2.23.0 use the existence validation method
     * @since 2.19.6
     *
     * @return mixed
     *
     * @throws RuntimeException
     */
    public function getAttribute(string $key)
    {
        $this->validatePropertyExists($key);

        return $this->attributes[$key] ?? null;
    }

    /**
     * Set a given attribute on the model.
     *
     * @since 2.23.0 validate that the property exists before setting
     * @since 2.19.6
     *
     * @param string $key
     * @param mixed  $value
     * @return void
     */
    public function setAttribute(string $key, $value)
    {
        $this->validatePropertyExists($key);
        $this->validatePropertyType($key, $value);

        $this->attributes[$key] = $value;
    }

    public function hasProperty($key): bool
    {
        return array_key_exists($key, $this->properties);
    }

    /**
     * Validate an attribute to a PHP type.
     *
     * @since 2.19.6
     *
     * @param string $key
     * @param mixed  $value
     *
     * @return bool
     */
    public function isPropertyTypeValid($key, $value)
    {
        if (is_null($value)) {
            return true;
        }

        $type = $this->getPropertyType($key);

        switch ($type) {
            case 'int':
                return is_int($value);
            case 'string':
                return is_string($value);
            case 'bool':
                return is_bool($value);
            case 'array':
                return is_array($value);
            default:
                return $value instanceof $type;
        }
    }

    /**
     * Validates that the given value is a valid type for the given property.
     *
     * @since 2.19.6
     *
     * @param string $key
     * @param mixed  $value
     * @return void
     *
     * @throws InvalidArgumentException
     */
    protected function validatePropertyType(string $key, $value)
    {
        if ( ! $this->isPropertyTypeValid($key, $value)) {
            $type = $this->getPropertyType($key);

            throw new InvalidArgumentException("Invalid attribute assignment. '$key' should be of type: '$type'");
        }
    }

    /**
     * Validates that the given property exists
     *
     * @since 2.23.0
     *
     * @return void
     * @throws InvalidArgumentException
     */
    protected function validatePropertyExists(string $key)
    {
        if ( !$this->hasProperty($key) ) {
            throw new InvalidArgumentException("Invalid property. '$key' does not exist.");
        }
    }

    /**
     * Get the property type
     *
     * @since 2.19.6
     */
    protected function getPropertyType(string $key): string
    {
        $type = is_array($this->properties[$key]) ? $this->properties[$key][0] : $this->properties[$key];

        return strtolower(trim($type));
    }

    /**
     * Get the default for a property if one is provided, otherwise default to null
     *
     * @since 2.20.0
     *
     * @param $key
     *
     * @return mixed|null
     */
    protected function getPropertyDefault($key)
    {
        return is_array($this->properties[$key]) && isset($this->properties[$key][1])
            ? $this->properties[$key][1]
            : null;
    }

    /**
     * Returns the defaults for all the properties. If a default is omitted it defaults to null.
     *
     * @since 2.20.0
     */
    protected function getPropertyDefaults(): array
    {
        $defaults = [];
        foreach (array_keys($this->properties) as $property) {
            $defaults[$property] = $this->getPropertyDefault($property);
        }

        return $defaults;
    }

    /**
     * @since 2.19.6
     */
    public function toArray(): array
    {
        return $this->attributes;
    }

    /**
     * @since 2.19.6
     */
    public function getAttributes(): array
    {
        return $this->attributes;
    }

    /**
     * @return int[]|string[]
     */
    public static function propertyKeys(): array
    {
        return array_keys((new static())->properties);
    }

    /**
     * Dynamically retrieve attributes on the model.
     *
     * @since 2.19.6
     *
     * @return mixed
     */
    public function __get(string $key)
    {
        if (array_key_exists($key, $this->relationships)) {
            return $this->getRelationship($key);
        }

        return $this->getAttribute($key);
    }

    /**
     * Dynamically set attributes on the model.
     *
     * @since 2.19.6
     *
     * @param string $key
     * @param mixed  $value
     *
     * @return void
     */
    public function __set($key, $value)
    {
        $this->setAttribute($key, $value);
    }

    /**
     * Determine if an attribute exists on the model.
     *
     * @since 2.19.6
     *
     * @param string $key
     *
     * @return bool
     */
    public function __isset($key)
    {
        return isset($this->attributes[$key]);
    }

    /**
     * @since 2.20.0 cache the relations after first load
     * @since 2.19.6
     *
     * @param $key
     *
     * @return Model|Model[]
     *
     * @throws InvalidArgumentException
     */
    protected function getRelationship($key)
    {
        if ( ! is_callable([$this, $key])) {
            throw new InvalidArgumentException("$key() does not exist.");
        }

        if ($this->hasCachedRelationship($key)) {
            return $this->cachedRelations[$key];
        }

        $relationship = new Relationship($this->relationships[$key]);

        switch (true) {
            case ($relationship->equals(Relationship::BELONGS_TO())):
            case ($relationship->equals(Relationship::HAS_ONE())):
                return $this->cachedRelations[$key] = $this->$key()->get();
            case ($relationship->equals(Relationship::HAS_MANY())):
            case ($relationship->equals(Relationship::BELONGS_TO_MANY())):
            case ($relationship->equals(Relationship::MANY_TO_MANY())):
                return $this->cachedRelations[$key] = $this->$key()->getAll();
        }

        return null;
    }

    /**
     * Checks whether a relationship has already been loaded.
     *
     * @since 2.20.0
     */
    protected function hasCachedRelationship(string $key): bool
    {
        return array_key_exists($key, $this->cachedRelations);
    }
}