<?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 WebClass
    {
        private $id, $name, $fields;

        public function __construct($id, $name)
        {
            $this->id = $id;
            $this->name = $name;
            $this->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 $class, $id, $name, $type;

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

        public function getClass() { return $this->class; }
        public function getID() { return $this->id; }
        public function getName() { return $this->name; }
        public function getType() { return $this->type; }
    }

    abstract class WebFieldType
    {
        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 $class, $id, $fields;

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

    abstract class DataSource
    {
        public function getUsersByID($ids) { return cachedLoad($ids, $this->userByIDCache, $this->loadUsersByID, [$this->userByEmailCache, function($user) { return $user->getEmail(); }]); }
        protected abstract function loadUsersByID($ids);
        protected $userByIDCache;

        public function getUsersByEmail($emails) { return cachedLoad($emails, $this->userByEmailCache, $this->loadUsersByEmail, [$this->userByIDCache, function($user) { return $user->getID(); }]); }
        protected abstract function loadUsersByEmail($emails);
        protected $userByEmailCache;

        public function getClassesByID($ids) { return cachedLoad($ids, $this->classByIDCache, $this->loadClassesByID, []); }
        protected abstract function loadClassesByID($ids);
        protected $classByIDCache;

        public function createClasses($names)
        {

        }

        protected abstract function constructClasses($names);

        protected function initialize()
        {
            $userByIDCache = [];
            $userByEmailCache = [];
        }

        protected function cachedLoad($keys, $cache, $load, $sharedCaches)
        {
            $objects = [];
            $uncachedKeys = [];
            foreach ($keys as $key)
            {
                if (array_key_exists($key, $cache))
                {
                    $objects[] = $cache[$key];
                }
                else
                {
                    $uncachedKeys[] = $key;
                }
            }

            if (count($uncachedKeys) > 0)
            {
                $loadedObjects = $load($uncachedKeys)

                foreach ($loadedObjects as $loadedObject)
                {
                    $key = $loadedObject['key'];
                    $object = $loadedObject['object'];

                    foreach ($sharedCaches as $sharedCache)
                    {
                        $sharedCache[0][$sharedCache[1]($object)] = $object;
                    }

                    $cache[$key] = $object;
                    $objects[] = $object;
                }
            }

            return $objects;
        }
    }

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

        protected function loadUserByID($id) { return null; }

        protected function loadUserByEmail($email) { return null; }

        protected function loadClassByID($id) { return null; }

        protected function constructClass($name)
        {

        }
    }

    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 $data;

        public function __construct($data)
        {
            $this->data = $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;
        }
    }

?>