<?php
/**
 * Class untuk berinteraksi dengan database
 *
 * @author Khaerul Amin
 * @version 1.0
 * @license FreeBSD
 */

if (!defined('HARMONI')) {
    exit;
}

class DataBase {
    /**
     * Konstan untuk index numeric dan asosiatif
     *
     */
    const BOTH = 1;

    /**
     * Konstan untuk index numeric
     *
     */
    const NUM = 2;

    /**
     * Konstan untuk index asosiatif
     *
     */
    const ASSOC = 4;

    /**
     * Konstan untuk objek
     *
     */
    const OBJ = 8;

    /**
     * Konstan untuk mendapatkan data sekaligus
     *
     * @var int
     * @access public
     * @constant
     */
    const ALL = 16;

    /**
     * Konstan untuk mengurutkan hasil query secara ascending (a-z)
     *
     * @var int
     * @access public
     * @constant
     */
    const ASC = 32;

    /**
     * Konstan untuk mengurutkan hasil query secara descending (z-a)
     *
     * @var int
     * @access public
     * @constant
     */
    const DESC = 64;

    /**
     * Tempat untuk menyimpan koneksi ke database
     *
     * @var object PDO
     * @access protected
     */
    protected static $pdo_dbh;

    /**
     * Tempat untuk menyimpan hasil query terakhir
     *
     * @var obj
     * @access protected
     */
    protected $pdo_stmt;

    /**
     * Internal token untuk membuat perintah sql
     *
     * @var array
     * @access protected
     */
    protected $arr_token;

    /**
     * Array konfigurasi untuk terhubung ke database
     *
     * @var array
     * @access protected
     */
    protected $arr_config;

    /**
     * Punctuation untuk klausa and dan or
     *
     * @var string
     * @access protected
     */
    protected $str_punc;

    /**
     * Perintah yang sedang dijalankan
     *
     * @var string
     * @access protected
     */
    protected $str_cmd;


    /**
     * Membuat instance baru
     *
     * @param array $config array konfigurasi untuk mengakses database
     * @return object PDO
     * @access public
     * @constructor
     */
    function __construct(array $config) {
        $this->str_punc = '';
        $this->str_cmd = '';
        $this->arr_token = [
            'select' => [],
            'insert' => [],
            'update' => [],
            'delete' => [],
            'create' => [],
            'clone'  => [],
            'copy'   => []
        ];
        $this->arr_config = $config;
        if (self::$pdo_dbh === null) {
            $this->internalConnect();
        }
    }

    /**
     * Destructor untuk class ini
     *
     * @return void
     * @access public
     */
    function __destruct() {
        self::$pdo_dbh = null;
        $this->pdo_stmt = null;
    }

    /**
     * Fungsi untuk menjalankan query string
     *
     * @return bool true jika berhasil dijalankan atau false jika gagal
     * @access public
     */
    function exec() {
        $this->pdo_stmt = null;
        $data = $this->internalBuildQuery();

        $sql = $data[0]; $filler = $data[1];
        $stmt = self::$pdo_dbh->prepare($sql);

        if ($filler) {
            $filler = $this->internalGetType($filler);

            // Isi semua placeholder
            foreach ($filler as $f) {
                $stmt->bindValue($f['index'], $f['value'], $f['type']);
            }
        }

        $stmt->execute();
        $this->pdo_stmt = $stmt;

        return $this;
    }

    /**
     * Mengambil nilai dari hasil PDO::exec
     *
     * Fungsi ini hanya boleh dipanggil ketika perintah sebelumnya adalah
     * DataBase::select jika tidak maka akan menampilkan error
     *
     * @param mixed &$var variable yang akan menerima hasil dari PDO::fetch
     * @param int $flag key yang akan dipakai
     * @return bool true jika masih ada data
     * @access public
     */
    function fetch(&$var, $flag = self::BOTH) {
        $cmd = $this->str_cmd;
        $stmt = $this->pdo_stmt;

        // Handle pemanggilan yang invalid
        if ($cmd !== 'select') {
            throw new Exception('DataBase::fetch: Hanya bisa dipanggil jika perintah terakhirnya DataBase::select');
        }

        // Handle jika sudah tidak ada data lagi
        if ($stmt === null) {
            $var = null;
            return false;
        }

        // Handle type berdasarkan flag.
        if (self::BOTH & $flag) {
            $type = PDO::FETCH_BOTH;
        }

        else if (self::ASSOC & $flag) {
            $type = PDO::FETCH_ASSOC;
        }

        else if (self::NUM & $flag) {
            $type = PDO::FETCH_NUM;
        }

        else if (self::OBJ & $flag) {
            $type = PDO::FETCH_OBJ;
        }

        else {
            $type = PDO::FETCH_BOTH;
        }

        // Handle jika user ingin mengambil data sekaligus
        if (self::ALL & $flag) {
            $var = $stmt->fetchAll($type);
            $this->pdo_stmt = null;

            return true;
        }

        $var = $stmt->fetch($type);

        !$var && $this->pdo_stmt = null;

        return $var !== false;
    }

    /**
     * Shortcut untuk DataBase::select('*', blablabla) yang terlihat nanggung
     *
     * @param string $table nama table tempat data berada
     * @return self
     * @access public
     */
    function selectAll($table) {
        return $this->select([ '*' ], $table);
    }

    /**
     * Fungsi untuk menjalankan Query yang rumit
     *
     * @param string $query kueri yang akan dieksekusi
     * @return mixed
     * @access public
     */
    function query($query) {
        return self::$pdo_dbh->query($query);
    }

    /**
     * Membuat perintah SELECT di sql
     *
     * @param mixed $column array yang berisi nama kolom yang akan dipilih. akan di rubah ke array jika bulan array
     * @param string $table nama table yang akan dipilih
     * @return self
     * @access public
     */
    function select($column, $table) {
        $this->str_cmd = 'select';

        // Reset setiap pemanggilan agar tidak terjadi konflik
        $this->arr_token['select'] = [];
        $token =& $this->arr_token['select'];

        !is_array($column) && $column = [ $column ];

        $token['column'] = $column;
        $token['table'] = $table;
        $token['where'] = [];
        $token['filter'] = [];
        $token['tokenize'] = true;

        return $this;
    }

    /**
     * Membuat perintah INSERT di sql
     *
     * @param string $table nama table yang akan dimasukan data baru
     * @param array $data nama kolom dan value yang akan dimasukan
     * @return self
     * @access public
     */
    function insert($table, array $data) {
        $this->str_cmd = 'insert';

        // Reset setiap pemanggilan agar tidak terjadi konflik
        $this->arr_token['insert'] = [];
        $token =& $this->arr_token['insert'];

        $token['table'] = $table;
        $token['column'] = array_keys($data);
        $token['data'] = array_values($data);
        $token['where'] = [];
        $token['tokenize'] = true;

        return $this;
    }

    /**
     * Menjalankan perintah UPDATE di sql
     *
     * @param string $table table yang akan diubah
     * @param array $data kolom yang akan dirubah dan nilai barunya
     * @return self
     * @access public
     */
    function update($table, array $data) {
        $this->str_cmd = 'update';

        // Reset setiap pemanggilan agar tidak terjadi konflik
        $this->arr_token['update'] = [];
        $token =& $this->arr_token['update'];

        $token['table'] = $table;
        $token['column'] = array_keys($data);
        $token['data'] = array_values($data);
        $token['where'] = [];
        $token['tokenize'] = true;

        return $this;
    }

   /**
     * Menjalankan fungsi DELETE di sql
     *
     * Untuk alasan keamanan database, fungsi ini akan menampilkan error jika
     * dipanggil tanpa ada WHERE klausa karena bisa menghapus semua data dalam suatu table
     *
     * @param string $table nama table dimana data akan dihapus
     * @return self
     * @access public
     */
    function delete($table) {
        $this->str_cmd = 'delete';

        // Reset setiap pemanggilan agar tidak terjadi konflik
        $this->arr_token['delete'] = [];
        $token =& $this->arr_token['delete'];

        $token['table'] = $table;
        $token['where'] = [];
        $token['tokenize'] = true;

        return $this;
    }

    /**
     * Menjalankan perintah CREATE TABLE di sql
     *
     * @param string $table nama table yang akan dibuat
     * @param array $data array untuk nama kolom dan tipe data
     *     misal: ['id' => 'SERIAL']
     * @param array $config konfigurasi meliputi:
     *     [x] use_if => true Haruskah menggunakan klausa IF NOT EXISTS
     *     [x] truncate => false Akan menghapus table jika table sudah ada
     *     [x] engine => InnoDB default storage engine
     *     [x] charset => utf-8 default charset
     *     [x] primary_key => ''
     *     [x] unique => '' kolom yang akan menjadi index
     * @return self
     * @access public
     */
    function create($table, array $data = [], array $config = []) {
        $this->str_cmd = 'create';

        // Reset setiap pemanggilan agar tidak terjadi konflik
        $this->arr_token['create'] = [];
        $token =& $this->arr_token['create'];

        // Default config
        // TODO: Mensupport multiple unique dan primary key
        static $default_config = [
            'use_if' => true,
            'truncate' => false,
            'engine' => 'InnoDB',
            'charset' => 'utf8',
            'primary_key' => '',
            'unique' => ''
        ];

        $config = array_merge($default_config, $config);

        $token['table'] = $table;
        $token['data'] = $data;
        $token['config'] = $config;
        $token['where'] = [];
        $token['tokenize'] = true;

        return $this;
    }

    /**
     * Membuat perintah CREATE TABLE LIE di sql
     *
     * Fungsi ini bertugas untuk mengcopy table satu ketable yang lain dalam satu database
     * Fungsi ini hanya mengcopy tablenya saja, jika ingin isinya juga gunakan DataBase::clone
     * Jika parameter pertama beripa array, maka akan diasumsikan bahwa key berupa $original_table dan valuenya $new_table
     *
     * @param string $original_table table asal yang akan dicopy
     * @param string $new_table nama table hasil dari copyan
     * @param array $config array konfigurasi meliputi:
     *     [x] use_if => true Jika true maka akan menggunakan klausa IF NOT EXIST
     *     [x] truncate => false Jika true akan menghapus table yang sudah ada
     * @return self
     * @access public
     */
    function cloneTable($original_table, $new_table = '', array $config = []) {
        $this->str_cmd = 'clone';

        // Reset dalam setiap pemanggilan
        $this->arr_token['clone'] = [];
        $token =& $this->arr_token['clone'];

        static $default_config = [
            'use_if' => true,
            'truncate' => false
        ];

        $config = array_merge($default_config, $config);
        $data = $original_table;
        $query = '';

        if (is_string($original_table)) {
            // Jika $original_table string, $new_table tidak boleh kosong
            if (empty($new_table)) {
                throw new Exception('DataBase::cloneTable: Nama table baru tidak boleh kosong');
            }

            $data = [ $original_table => $new_table ];
        }

        foreach ($data as $old => $new) {
            if (empty($old) || empty($new)) {
                throw new Exception(__METHOD__ . ': Original Table atau New Table tidak boleh kosong');
            }

            if ($config['truncate']) {
                $query .= "DROP TABLE IF EXISTS {$new};";
            }

            $query .= $config['use_if'] ?
                "CREATE TABLE IF NOT EXISTS {$new} LIKE {$old};" :
                    "CREATE TABLE {$new} LIKE {$old};";
        }

        $token['tokenize'] = false;
        $token['query'] = $query;

        return $this;
    }

    /**
     * Membuat perintah SELECT INTO di sql
     *
     * @param array|string $column nama kolom yang akan diclone. Jika berupa string akan dirubah kebentuk array
     * @param string $original_table nama tabledimana data akan diambil
     * @param atring $target_table table dimana data baru akan ditempatkan
     * @param array|string $dest kolom tempat data akan dimasukan
     * @return self
     * @access public
     */
    function copyTable($original_table, $target_table, $column, $dest = '') {
        $this->str_cmd = 'copy';

        // Reset dalam setiap pemanggilan
        $this->arr_token['copy'] = [];
        $token =& $this->arr_token['copy'];

        // Rubah kebentuk array jika bukan array
        if (!is_array($column)) {
            $column = [ $column ];
        }

        if (!is_array($dest)) {
            $dest = [ $dest ];
        }

        $token['original'] = $original_table;
        $token['target'] = $target_table;
        $token['column'] = $column;
        $token['destination'] = $dest;
        $token['where'] = [];
        $token['tokenize'] = true;

        return $this;
    }

    /**
     * Shortcut untuk mengklon seluruh data dari satu table ke table yang lain
     *
     * @param string $original_table table dimana data berada
     * @param string $target_table table data akab disimpan
     * @return self
     * @access public
     */
    function copyAll($original_table, $target_table) {
        return $this->copyTable($original_table, $target_table, [ '*' ], [ '' ]);
    }

    /**
     * Membuat WHERE klausa di sql
     *
     * Jika parameter pertama array maka akan diasumsikan itu adalah multiple
     * where dimana key berupa nama kolom dan value berupa nilai-nya dengan tanda
     * penghubung sama dengan (=) dan setiap where dipisahkan dengan Klausa AND
     *
     * @param mixed $column nama kolom yang akan ditest
     * @param mixed $condition kondisi yang akan dites (=|!=|<>|like|..)
     * @param mixed $value nilai yang akan ditest
     * @return self
     * @access public
     */
    function where($column, $condition = '', $value = '') {
        // Perintah yang dijalankan saat ini. (SELECT|UPDATE|DELETE|..)
        $cmd = $this->str_cmd;

        // Handle penggunaan where yang tidak valid
        if ($cmd === '') {
            // TODO: Membuat class DataBaseException
            throw new Exception('DataBase::where: Penggunaan where yang tidak benar');
        }

        $token =& $this->arr_token[$cmd];

        // Handle simple where
        if (!is_array($column)) {
            $token['where'][] = [
                'punctuation' => $this->str_punc,
                'column' => $column,
                'condition' => $condition,
                'value' => $value
            ];
            $this->str_punc = '';

            return $this;
        }

        // Ok. jadi ini adalah multiple where jadi
        $first = true;
        foreach ($column as $column => $value) {
            $punc = 'AND';

            // Handle pertama kali
            if ($first) {
                $first = false;
                $punc = $this->str_punc;
                $this->str_punc = '';
            }

            $token['where'][] = [
                'punctuation' => $punc,
                'column' => $column,
                'value' => $value,
                'condition' => '='
            ];
        }

        return $this;
    }

    /**
     * Membuat klausa ORDER | LIMIT | OFFSET di perintah sql
     *
     * Jika perintah yang dijalankan bukan DataBase::select maka akan diabaikan secara tersembunyi
     *
     * @param array $preference konfigurasi yang diharapkan
     * @return self
     * @access public
     */
    function filter(array $preference) {
        // Kembali, jika bukan select
        if ($this->str_cmd !== 'select') {
            return $this;
        }

        $filter =& $this->arr_token['select']['filter'];

        // foreach lebih praktis
        if (isset($preference['order'])) {
            $order = $preference['order'];
            if (!is_array($order)) {
                $col = $order;
                $dir = 'ASC';
            } else {
               $col = $order[0];
               $dir = (self::DESC & $order[1]) ? 'DESC' : 'ASC';
            }

            $filter['order'] = [
                'column' => $col,
                'direction' => $dir
            ];
        }

        if (isset($preference['limit'])) {
            $filter['limit'] = $preference['limit'];
        }

        // Harus ada limit jika offset diset. Akan error di mysql jika ada offset tanpa limit
        if (isset($preference['offset']) && isset($preference['limit'])) {
            $filter['offset'] = $preference['offset'];
        }

        return $this;
    }

    /**
     * Menjalankan klausa AND di sql
     *
     * Ada suffix s karena AND sudah didefine oleh PHP sehingga kita tidak bisa menggunakan fungsi tersebut
     *
     * @return self
     * @access public
     */
    function ands() {
        $this->str_punc = 'AND';

        return $this;
    }

    /**
     * Menjalankan klausa OR di sql
     *
     * Ada suffix s karena OR sudah didefine oleh PHP sehingga kita tidak bisa menggunakan fungsi tersebut
     *
     * @return self
     * @access public
     */
    function ors() {
        $this->str_punc = 'OR';

        return $this;
    }

    /**
     * Internal fungsi untuk membuat perintah SQL
     *
     * @return string
     * @access private
     */
    private function internalBuildQuery() {
        // Perintah saat ini
        $cmd = $this->str_cmd;

        // Handle jika perintah tidak perlu ditokenize
        if (!$this->arr_token[$cmd]['tokenize']) {
            return [ $this->arr_token[$cmd]['query'], false ];
        }

        switch ($cmd) {
            case 'select':
                return $this->internalBuildSelect();

            case 'insert':
                return $this->internalBuildInsert();

            case 'update':
                return $this->internalBuildUpdate();

            case 'delete':
                return $this->internalBuildDelete();

            case 'create':
                return $this->internalBuildCreate();

            case 'copy':
                return $this->internalBuildCopy();

            default:
                throw new Exception('DataBase::internalBuildQuery: Methode tidak dikenali');
        }
    }

    /**
     * Membuat SQL query dengan perintah SELECT dari token yang ada
     *
     * @return array
     * @access private
     */
    private function internalBuildSelect() {
        $ret = '';
        $cmd = $this->str_cmd;
        $extra = ['', false];
        $token = $this->arr_token[$cmd];

        $column = implode(',', $token['column']);
        $ret .= "SELECT $column FROM {$token['table']}";

        if (count($token['where'])) {
            $extra = $this->internalBuildWhere($token['where']);
            $ret .= " $extra[0] ";
        }

        if (count($token['filter'])) {
            $filter = $token['filter'];
            if (isset($filter['order'])) {
                $order = $filter['order'];
                $ret .= " ORDER BY {$order['column']} {$order['direction']} ";
            }

            if (isset($filter['limit'])) {
                $ret .= " LIMIT {$filter['limit']} ";

                if (isset($filter['offset'])) {
                    $ret .= " OFFSET {$filter['offset']} ";
                }
            }
        }

        return [ $ret, $extra[1] ];
    }

    /**
     * Membuat SQL query dengan perintah INSERT dari token yang ada
     *
     * @return array array yang berisi query string dan data untuk placeholder untuk digunakan di PDO::prepare
     * @access private
     */
    private function internalBuildInsert() {
        // Perintah saat ini
        $ret = '';
        $cmd = $this->str_cmd;
        $token = $this->arr_token[$cmd];

        $column = $token['column'];
        $data = $token['data'];

        $holder = $this->internalCreatePlaceholder(count($data));
        $str_column = implode(',', $column);
        $str_holder = implode(',', $holder);

        $ret .= "INSERT INTO {$token['table']} ($str_column) VALUES ($str_holder)";

        // INSERT tidak perlu WHERE klausa
        return [$ret, $data];
    }

    /**
     * Membuat SQL query UPDATE dari token yang ada
     *
     * @return array
     * @access private
     */
    private function internalBuildUpdate() {
        $ret = '';
        $extra = ['', false];
        $cmd = $this->str_cmd;
        $token = $this->arr_token[$cmd];

        $column = $token['column'];
        $data = $token['data'];
        // $holder = $this->internalCreatePlaceholder(count($data));

        $str_column = implode(',', $column);

        if (count($token['where'])) {
            $extra = $this->internalBuildWhere($token['where']);
        }

        $ret .= "UPDATE {$token['table']} SET";
        foreach ($column as $col) {
            $ret .= " $col = ?,";
        }
        $ret = rtrim($ret, ',');

        // Mungkin saja ada where klausa
        if ($extra[1] !== false) {
            $ret .= " $extra[0]";
            $data = array_merge($data, $extra[1]);
        }

        return [$ret, $data];
    }

    /**
     * Membuat SQL query DELETE dari token yang tersedia
     *
     * @return array
     * @access private
     */
    private function internalBuildDelete() {
        $ret = '';
        $cmd = $this->str_cmd;
        $token = $this->arr_token[$cmd];

        // DELETE tanpa WHERE klausa
        if (!count($token['where'])) {
            throw new Exception('DataBase::internalBuildDelete: Tidak ada WHERE klausa');
        }

        $ret .= "DELETE FROM {$token['table']}";
        $extra = $this->internalBuildWhere($token['where']);

        return [ "$ret {$extra[0]}", $extra[1] ];
    }

    /**
     * Membuat SQL query CREATE TABLE menggunakan token yang sudah ada
     *
     * @return array
     * @access private
     */
    private function internalBuildCreate() {
        $ret = '';
        $cmd = $this->str_cmd;
        $token = $this->arr_token[$cmd];

        $table = $token['table'];
        $data = $token['data'];
        $config = $token['config'];

        //-> Membuat klausa CREATE TABLE
        // Jika truncate true, hapus table terlebih dahulu jika ada
        if ($config['truncate']) {
            $ret .= "DROP TABLE IF EXISTS {$table};";
        }

        // Jika use_if true, gunakan klausa IF NOT EXISTS
        $ret .= $config['use_if'] ?
            "CREATE TABLE IF NOT EXISTS {$table}" :
                "CREATE TABLE {$table}";
        $ret .= ' ( ';

        // Tambahkan kolom dan definisinya
        foreach ($data as $column => $definition) {
            $ret .= "$column $definition,";
        }

        // Tambahkan Primary Key konstrain jika diset
        if ($config['primary_key']) {
            $ret .= "PRIMARY KEY({$config['primary_key']}),";
        }

        // Tambahkan Unique konstrain jika diset
        if ($config['unique']) {
            $ret .= "UNIQUE ({$config['unique']}),";
        }

        $ret = rtrim($ret, ',');
        $ret .= ') ';

        // Set Engine, Charset
        $ret .= "ENGINE={$config['engine']} DEFAULT CHARSET={$config['charset']};";

        return [ $ret, false ];
    }

    /**
     * Memparse perintah clone sari token yang sudah ada
     *
     * @return array
     * @access private
     */
    private function internalBuildCopy() {
        $ret = '';
        $extra = [ '', false ];
        $cmd = $this->str_cmd;
        $token = $this->arr_token[$cmd];

        $original = $token['original'];
        $target = $token['target'];
        $column = $token['column'];
        $dest = $token['destination'];

        // Handle Ketika tidak ada kolom yang dipilih
        if (!count($column) ||
            empty($column[0]) ||
            ($column[0] !== '*' &&
            (!count($dest) ||
            empty($dest[0])))
        ) {
            throw new Exception('DataBase::internalBuildCopy: Memerlukan paling tidak satu kolom untuk dipilih dan tempat data diletakan');
        }

        // Handle SELECT *
        // NOTE: Hanya mengecek secara naif
        if ($column[0] === '*') {
            $ret .= "INSERT INTO ${target} SELECT * FROM ${original}";
        } else {
            // Langkah pertama pastikan kolom yang dipilih dan kolom tujuan memiliki jumlah yang sama.
            // Saya juga inginnya mengechek apakah tipe datanya juga sama tapi biarkan mysql yang menghandlenya.
            if (count($column) !== count($dest)) {
               throw new Exception('DataBase::internalBuildCopy: Jumlah kolom data berasal tidak sama dengan jumlah kolom tujuan');
            }

            $str_column = implode(',', $column);
            $str_dest = implode(',', $dest);

            $ret .= "INSERT INTO ${target} (${str_dest}) SELECT ${str_columb} FROM ${original}";
        }

        if (count($token['where'])) {
            $extra = $this->internalBuildWhere($token['where']);

            $ret .= " {$extra[0]}";
        }

        return [ $ret, $extra[1] ];
    }

    /**
     * Membuat placeholder untuk PDO::prepare
     *
     * @param int $count jumlah placeholder yang akan dibuat
     * @return array
     * @access private
     */
    private function internalCreatePlaceholder($count) {
        $ret = [];
        foreach (range(1, $count) as $num) {
            $ret[] = '?';
        }

        return $ret;
    }

    /**
     * Memparse WHERE klausa sesuai token
     *
     * @param array $token token yang akan di parse
     * @return array
     * @access private
     */
    private function internalBuildWhere(array $token) {
        $ret = ['WHERE ', []];

        foreach ($token as $T) {
            $tmp = '';
            !empty($T['punctuation']) && $tmp .= " {$T['punctuation']} ";
            $tmp .= "{$T['column']} {$T['condition']} ?";

            $ret[0] .= $tmp;
            $ret[1][] = $T['value'];
        }

        return $ret;
    }

    /**
     * Menentukan tipe data sebuah data sebelum dikirim ke database
     *
     * @param array $data data yang akan dikirim ke database
     * @return array
     * @access private
     */
    private function internalGetType(array $data) {
        $translation = [
            'string' => PDO::PARAM_STR,
            'integer' => PDO::PARAM_INT,
            'double' => PDO::PARAM_INT,
            'null' => PDO::PARAM_NULL,
            'bool' => PDO::PARAM_BOOL
        ]; $ret = [];

        foreach ($data as $k => $v) {
            $type = gettype($v);
            $type = isset($translation[$type]) ? $translation[$type] : PDO::PARAM_STR;
            $ret[] = [
                'index' => $k + 1,
                'value' => $v,
                'type' => $type
            ];
        }

        return $ret;
    }

    /**
     * Internal fungsi untuk mengkoneksi ke database
     *
     * Jika tidak ada konfigurasi maka secara default akan menggunakan konfigurasi yang
     * ada di file /harmoni/config.php
     *
     * @return void
     * @access private
     */
    private function internalConnect() {
        $config = $this->arr_config;

        $host = isset($config['host']) ? $config['host'] : DB_HOST;
        $user = isset($config['user']) ? $config['user'] : DB_USER;
        $pass = isset($config['pass']) ? $config['pass'] : DB_PASS;
        $name = isset($config['name']) ? $config['name'] : DB_NAME;

        $dsn = "mysql: host=$host; dbname=$name";

        try {
            self::$pdo_dbh = new PDO($dsn, $user, $pass);
            // Production : PDO::ERRMODE_SILENT
            // Development: PDO::ERRMODE_EXCEPTION
            self::$pdo_dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        } catch (PDOException $error) {
            // Berhenti mengeksekusi skrip karena koneksi ke database gagal
            exit($error->getMessage());
        }
    }
}

?>