<?php

    namespace VWA;

    class Database
    {
        private $system, $host, $port, $name, $user, $pass, $pdo;

        public function __construct($system, $host, $port, $name, $user, $pass)
        {
            $this->system = $system;
            $this->host = $host;
            $this->port = $port;
            $this->name = $name;
            $this->user = $user;
            $this->pass = $pass;
            $this->pdo = new \PDO($system.':host='.$host.';port='.$port.';dbname='.$name.';', $user, $pass);
        }

        public function getPDO() { return $this->pdo; }
        public function getSystem() { return $this->system; }

        public static function createParameterList($count)
        {
            if ($count == 0)
            {
                return '';
            }
            else if ($count == 1)
            {
                return '?';
            }
            else
            {
                $output = '?';
                for ($i = 1; $i < $count; $i++)
                {
                    $output .= ', ?';
                }

                return $output;
            }
        }

        public function execute($query, $parameters = [])
        {
            $statement = $this->pdo->prepare($query);

            if (count($parameters) > 0)
            {
                $statement->execute($parameters);
            }
            else
            {
                $statement->execute();
            }

            echo '<br>';
            echo $query;
            echo '<br>';

            return $statement;
        }

        public function select($table, $columns, $condition = '', $parameters = [])
        {
            $query = 'SELECT ';

            $first = true;
            foreach ($columns as $column)
            {
                if ($first)
                {
                    $query .= $column;
                    $first = false;
                }
                else
                {
                    $query .= ', '.$column;
                }
            }

            $query .= ' FROM '.$table;

            if ($condition != '')
            {
                $query .= ' WHERE '.$condition;
            }

            return $this->execute($query, $parameters)->fetchAll(\PDO::FETCH_ASSOC);
        }

        public function selectUnique($table, $columns, $targetColumn, $parameter)
        {
            $result = $this->database->select('users', ['*'], $targetColumn.' = ?', [$parameter]);
            if (count($result) == 0)
            {
                return null;
            }
            else
            {
                return $result[0];
            }
        }

        public function insert($table, $columns, $parameters = [])
        {
            return $this->insertMany($table, $columns, [$parameters]);
        }

        public function insertMany($table, $columns, $rows = [[]])
        {
            $query = 'INSERT INTO '.$table.' (';

            $first = true;
            foreach ($columns as $column)
            {
                if ($first)
                {
                    $query .= $column;
                    $first = false;
                }
                else
                {
                    $query .= ', '.$column;
                }
            }

            $query .= ') VALUES ';

            $outputRow = function($row)
            {
                $output = '(';
                $first = true;
                foreach ($row as $value)
                {
                    if ($first)
                    {
                        $output .= '?';
                        $first = false;
                    }
                    else
                    {
                        $output .= ', ?';
                    }
                }

                $output .= ')';

                return $output;
            };

            $parameters = [];
            $first = true;
            foreach ($rows as $row)
            {
                if ($first)
                {
                    $query .= $outputRow($row);
                    $first = false;
                }
                else
                {
                    $query .= ', '.$outputRow($row);
                }

                foreach ($row as $value)
                {
                    $parameters[] = $value;
                }
            }

            echo '<br>START<br>';

            echo $query;
            echo '<br>';
            print_r($parameters);

            $this->execute($query, $parameters);
            return $this->pdo->lastInsertId();
        }
    }

    class User
    {
        private $id, $name, $email, $pass;

        public function __construct($id, $name, $email, $pass)
        {
            $this->id = $id;
            $this->name = $name;
            $this->email = $email;
            $this->pass = $pass;
        }

        public function getID() { return $this->id; }
        public function getName() { return $this->name; }
        public function getEmail() { return $this->email; }
        public function getPass() { return $this->pass; }
    }

    abstract class LoginResponse
    {
        const UnknownEmail = 0;
        const InvalidPass = 1;
        const Success = 2;
    }

    class Type
    {
        public static function createFromID($id)
        {
            return Core::getInstance()->getData()->getTypeByID($id);
        }

        private $id, $name, $fields;

        public function __construct($id, $name, $fields = [])
        {
            $this->id = $id;
            $this->name = $name;
            $this->fields = $fields;
        }

        public function getID() { return $this->id; }
        public function getName() { return $this->name; }
        public function getFields() { return $this->fields; }

        /*public function addFields($fields)
        {
            $rows = [];
            foreach ($fields as $field)
            {
                $rows[] = [$this->id, $field[0], $field[1]];
            }

            global $vwa;
            $lastID = $vwa->getDatabase()->insertMany('fields', ['class', 'name', 'type'], $rows);

            $offset = count($fields) - 1;
            $i = 0;
            foreach ($fields as $field)
            {
                $this->fields[] = new Field($this, $lastID - $offset + $i);
                $i++;
            }
        }

        public function addField($field)
        {
            $this->addFields([$field]);
        }

        public function internalAddField($field)
        {
            $this->fields[] = $field;
        }*/
    }

    class Field
    {
        private $parentTypeID, $id, $name, $type;

        public function __construct($parentTypeID, $id, $name, $type)
        {
            $this->parentTypeID = $parentTypeID;
            $this->id = $id;
            $this->name = $name;
            $this->type = $type;
        }

        public function getParentTypeID() { return $this->parentTypeID; }
        public function getParentType() { return Type::createFromID($this->parentTypeID); }
        public function getID() { return $this->id; }
        public function getName() { return $this->name; }
        public function getType() { return $this->type; }
    }

    abstract class FieldType
    {
        const Boolean = 0;
        const Integer = 1;
        const BigInteger = 2;
        const Number = 3;
        const PreciseNumber = 4;
        const Text = 5;
        const Enumeration = 6;
        const Object = 7;
    }

    class Entity
    {
        private $parentTypeID, $id, $fields;

        public function __construct($parentTypeID, $id)
        {
            $this->parentTypeID = $parentTypeID;
            $this->id = $id;
            $this->fields = [];
        }

        public function getParentTypeID() { return $this->parentTypeID; }
        public function getParentType() { return Type::createFromID($this->parentTypeID); }
        public function getID() { return $this->id; }
        public function getFields() { return $this->fields; }
    }

    class DataCache
    {
        private $fullCreate, $fullGet, $getKey, $objects, $attachedCaches;

        public function __construct($fullCreate, $fullGet, $getKey = null)
        {
            if ($getKey == null)
            {
                $this->getKey = function($object) { return $object->getID(); };
            }
            else
            {
                $this->getKey = $getKey;
            }

            $this->fullCreate = $fullCreate;
            $this->fullGet = $fullGet;
            $this->objects = [];
            $this->attachedCaches = [];
        }

        public function attach($caches)
        {
            foreach ($caches as $cache)
            {
                $this->attachedCaches[] = $cache;
            }
        }

        public function getKey($object)
        {
            return $this->getKey($object);
        }

        public function get($key)
        {
            return $this->getFirstOrNull($this->getMultiple([$key]));
        }

        public function getMultiple($keys)
        {
            $objects = [];
            $uncachedKeys = [];
            foreach ($keys as $key)
            {
                if (array_key_exists($key, $this->objects))
                {
                    $objects[$key] = $this->objects[$key];
                }
                else
                {
                    $uncachedKeys[] = $key;
                }
            }

            if (count($uncachedKeys) > 0)
            {
                $loadedObjects = $this->fullGet($keys);
                $this->putInCache($loadedObjects);
                $objects = array_merge($objects, $loadedObjects);
            }

            return $objects;
        }

        public function create($args)
        {
            return $this->getFirstOrNull(createMultiple([$args]));
        }

        public function createMultiple($argLists)
        {
            $objects = $this->fullCreate($argLists);
            $this->putInCache($objects);
            return $objects;
        }

        private function getFirstOrNull($collection)
        {
            if (count($collection) == 0)
            {
                return null;
            }
            else
            {
                return $collection[0];
            }
        }

        private function putInCache($objects)
        {
            foreach ($objects as $object)
            {
                $this->objects[$this->getKey($object)] = $object;
                foreach ($this->attachedCaches as $cache)
                {
                    $cache->objects[$cache->getKey($object)] = $object;
                }
            }
        }
    }

    abstract class DataSource
    {
        private $users, $usersByEmail;
        protected abstract function createUsers($argLists);
        protected abstract function getUsers($ids);
        protected abstract function getUsersByEmail($emails);

        private $types;
        protected abstract function createTypes($argLists);
        protected abstract function getTypes($ids);

        protected function initialize()
        {
            $this->users = new DataCache(callable $this->createUsers, $this->getUsers);
            $this->usersByEmail = new DataCache($this->createUsers, $this->getUsersByEmail, function($user) { return $user->getEmail(); });

            $this->users->attach([$this->usersByEmail]);
            $this->usersByEmail->attach([$this->users]);

            $this->types = new DataCache($this->createTypes, $this->getTypes);
        }
    }

    class TemporaryDataSource extends DataSource
    {
        public function __construct()
        {
            $this->initialize();
        }

        protected function createUsers($argLists)
        {
            $users = [];
            foreach ($argLists as $argList)
            {
                $users[] = new User($argList['id'], $argList['name'], $argList['email'], $argList['pass']);
            }

            return $users;
        }

        protected function getUsers($ids) { return []; }

        protected function getUsersByEmail($emails) { return []; }

        protected function createTypes($argLists)
        {
            $types = [];
            foreach ($argLists as $argList)
            {
                $types[] = new Type($argList['id'], $argList['name']);
            }

            return $types;
        }

        protected function getTypes($ids) { return []; }
    }

    /*class DatabaseDataSource extends DataSource
    {
        private $database;

        public function __construct($database)
        {
            $this->initialize();
            $this->database = $database;
        }

        protected function loadUsersByID($ids)
        {
            $result = $this->database->select('users', ['name', 'email', 'pass'], 'id = IN('.createParameterList(count($ids)).')', $ids);
            if ($result == null)
            {
                return null;
            }
            else
            {
                return ['key' => $id, 'object' => new User($id, $result['name'], $result['email'], $result['pass'])];
            }
        }

        protected function loadUsersByEmail($emails)
        {
            $result = $this->database->selectUnique('users', ['id', 'name', 'pass'], 'email', $email);
            if ($result == null)
            {
                return null;
            }
            else
            {
                return ['key' => $email, 'object' => new User($result['id'], $result['name'], $email, $result['pass'])];
            }
        }

        protected function loadClassesByID($ids)
        {
            $result = $this->database->selectUnique('classes', ['name'], 'id', $id);
            if ($result == null)
            {
                return null;
            }

            $class = new WebClass($result[0]['id'], $name);

            $result = $this->database->select('fields', ['id', 'name', 'type'], 'class = ?', [$class->getID()]);
            foreach ($result as $row)
            {
                $class->internalAddField(new Field($class, $row['id'], $row['name'], $row['type']));
            }

            return $class;
        }

        protected function constructClasses($names)
        {

        }
    }*/

    class Core
    {
        private static $instance;

        public static function getInstance()
        {
            return Core::$instance;
        }

        private $data;

        public function __construct($data)
        {
            Core::$instance = $this;
            $this->data = $data;
        }

        public function getData()
        {
            return $this->data;
        }

        public function login($email, $pass)
        {
            $user = $this->data->getUserByEmail($email);
            if ($user == null)
            {
                return LoginResponse::UnknownEmail;
            }
            else if (!password_verify($pass, $user->pass))
            {
                return LoginResponse::InvalidPass;
            }
            else
            {
                session_destroy();
                session_start();
                $_SESSION['user'] = $user;
                return LoginResponse::Success;
            }
        }

        public function logout()
        {
            session_destroy();
        }

        public function getCurrentUser()
        {
            if (!isset($_SESSION['user']))
            {
                return null;
            }
            else
            {
                return $_SESSION['user'];
            }
        }

        public function addClass($name, $fields = [])
        {
            $id = $this->database->insert('classes', ['name'], [$name]);
            $class = new WebClass($id, $name);

            if (count($fields) > 0)
            {
                $class->addFields($fields);
            }

            return $class;
        }

        public function getClass($name)
        {
            $result = $this->database->select('classes', ['id'], 'name = ?', [$name]);
            if (count($result) == 0)
            {
                return null;
            }

            $class = new WebClass($result[0]['id'], $name);

            $result = $this->database->select('fields', ['id', 'name', 'type'], 'class = ?', [$class->getID()]);
            foreach ($result as $row)
            {
                $class->internalAddField(new Field($class, $row['id'], $row['name'], $row['type']));
            }

            return $class;
        }
    }



    new Core(new TemporaryDataSource());




?>