<?php

namespace Ulmus\Adapter;

use Ulmus\{Common\Sql,
    ConnectionAdapter,
    Entity\InformationSchema\Table,
    Migration\FieldDefinition,
    Repository,
    QueryBuilder,
    Ulmus};

trait SqlAdapterTrait
{
    public function repositoryClass() : string
    {
        return Repository::class;
    }

    public function queryBuilderClass() : string
    {
        return QueryBuilder::class;
    }

    public function tableSyntax() : array
    {
        return [
            'ai' => "AUTO_INCREMENT",
            'pk' => "PRIMARY KEY",
            'unsigned' => "UNSIGNED",
        ];
    }

    public function databaseName() : string
    {
        return $this->database;
    }

    public function schemaTable(ConnectionAdapter $adapter, $databaseName, string $tableName) : null|object
    {
        return Table::repository(Repository::DEFAULT_ALIAS, $adapter)
            ->select(\Ulmus\Common\Sql::raw('this.*'))
            ->where($this->escapeIdentifier('table_schema', AdapterInterface::IDENTIFIER_FIELD), $databaseName)
            ->loadOneFromField($this->escapeIdentifier('table_name', AdapterInterface::IDENTIFIER_FIELD), $tableName);
    }

    public function mapFieldType(FieldDefinition $field, bool $typeOnly = false) : string
    {
        $type = $field->type;

        $length = $field->length;

        if ( is_a($type, Entity\Field\Date::class, true) ) {
            $type = "DATE";
        }
        elseif ( is_a($type, Entity\Field\Time::class, true) ) {
            $type = "TIME";
        }
        elseif ( is_a($type, \DateTime::class, true) ) {
            $type = "DATETIME";
        }

        switch($type) {
            case "bool":
                $type = "TINYINT";
                $length = 1;
                break;

            case "array":
            case "string":
                if ($length && $length <= 255) {
                    $type = "VARCHAR";
                    break;
                }
                elseif (! $length || ( $length <= 65535 ) ) {
                    $type = "TEXT";
                }
                elseif ( $length <= 16777215 ) {
                    $type = "MEDIUMTEXT";
                }
                elseif ($length <= 4294967295) {
                    $type = "LONGTEXT";
                }
                else {
                    throw new \Exception("A column with size bigger than 4GB cannot be created.");
                }

                # Length is unnecessary on TEXT fields
                unset($length);

                break;

            case "float":
                $type = "DOUBLE";
                break;

            default:
                $type = strtoupper($type);
                break;
        }

        return $typeOnly ? $type : $type . ( isset($length) ? "($length" . ( ! empty($precision) ? ",$precision" : "" ) . ")" : "" );
    }

    public function whitelistAttributes(array &$parameters) : void
    {
        $parameters = array_intersect_key($parameters, array_flip(static::ALLOWED_ATTRIBUTES));
    }

    public function generateAlterColumn(FieldDefinition $definition, array $field) : string|\Stringable
    {
        if (! empty($field['previous']) ) {
            $position = sprintf('AFTER %s', $this->escapeIdentifier($field['previous']->field, AdapterInterface::IDENTIFIER_FIELD));
        }
        else {
            $position = "FIRST";
        }

        return implode(" ", [
            strtoupper($field['action']),
            $this->escapeIdentifier($definition->getSqlName(), AdapterInterface::IDENTIFIER_FIELD),
            $definition->getSqlType(),
            $definition->getSqlParams(),
            $position,
        ]);
    }

    public function writableValue(mixed  $value) : mixed
    {
        switch (true) {
            case $value instanceof \UnitEnum:
                return Ulmus::convertEnum($value);

            case is_object($value):
                return Ulmus::convertObject($value);

                case is_array($value):
                return json_encode($value);

            case is_bool($value):
                return (int) $value;
        }

        return $value;
    }
    
    public function splitAlterQuery() : bool
    {
        return false;
    }
}