<?php

class DB {

        private static $instance;
        private static $con;
        private static $customError;

        public static function init($host, $user, $pass, $db) {

            if(!isset(self::$instance)) {

                try {
                    self::$instance = new PDO('mysql:host='.$host.';dbname='.$db, $user, $pass);
                    //self::$instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
                    self::$con = true;
                }
                catch (PDOException $e) {

                    self::$customError = $e->getMessage();
                    self::$con = false;
                }
            }
        }

        public static function isConnected() {

            return self::$con;
        }

        public static function select($table, $columns = '*', $where = NULL, $limit = NULL)
        {
            $sql = "SELECT $columns FROM $table";
            $params = array();

            if($where != NULL)
            {
                if(!is_array($where))
                {
                    echo 'Error in DB::select function: \'where\' parameter must be Array';
                    return false;
                }
                if(!is_array($where[0]) && count($where) == 2)
                {
                    $where = array($where);
                }


                $sql .= " WHERE";

                for($i = 0; $i < count($where); $i++)
                {
                    $w = $where[$i];

                    if(is_array($w))
                    {
                        if(count($w) == 2)
                        {
                            $sql .= " `$w[0]` = ?";
                            $params[] = $w[1];
                        }
                        else if(count($w) == 3)
                        {
                            $sql .= " `$w[0]` $w[1] = ?";
                            $params[] = $w[2];
                        }

                        if($i != count($where)-1)
                        {
                            $sql = " AND";
                        }
                    }
                }
            }

            if($limit != NULL)
            {
                $sql = " LIMIT $limit";
            }

            return self::query($sql, $params);
        }

        public static function query($query, $params = array()) {

            try {
                $params = !is_array($params) ? array($params) : $params;
                $data = array();
                $is_select = strtoupper(substr($query,0,6)) == "SELECT" ? true : false;

                if(count($params) > 0) {

                    $stmt = self::$instance->prepare($query);

                    if(!$stmt)
                    {
                        return false;
                    }

                    $stmt->execute($params);

                    if($is_select)
                        $data = $stmt->fetchAll(PDO::FETCH_ASSOC);
                    else {
                        $data = true;
                    }

                    $stmt->closeCursor();
                }
                else {

                    $res = self::$instance->query($query);

                    if(!$res)
                    {
                        return false;
                    }
                    else if($is_select)
                    {
                        foreach($res as $row)
                            $data[] = $row;
                    }
                    else
                    {
                        $data = true;
                    }
                }

                self::$customError = "";

                return $data;
            }
            catch(Exception $e) {

                self::setError($e->getMessage());
                return false;
            }
        }

        public static function getError() {

            if(strlen(self::$customError) > 0)
            {
                return self::$customError;
            }
            else
            {
                $err = self::$instance->errorInfo();
                return $err[count($err)-1];
            }
        }

        public static function setError($e) {

            self::$customError = $e;
        }
    }

    // shit class
    class DB2 {

        private static $i;
        private static $con;
        private static $customError;

        public static function init($host, $user, $pass, $db) {

            if(!isset(self::$i)) {

                self::$i = new mysqli($host, $user, $pass, $db);
                self::$con = !(self::$i->connect_errno > 0);
                self::$customError = "";
            }
        }

        public static function isConnected() {
            return self::$con;
        }

        public static function ConnectionError() {
            return self::$i->connect_error;
        }

        public static function tableExists($tbl_name) {

            $q = self::query("SHOW TABLES LIKE ?", $tbl_name);

            return !!$q && count($q) > 0;
        }

        public static function rawQuery($q) {
            return self::$i->query($q);
        }
        private static function getTypes($params)
        {
            $param_type = '';

            foreach($params as $p)
            {
                switch(gettype($p))
                {
                    case 'blob':
                        $param_type .= 'b';
                        break;
                    case 'double':
                        $param_type .= 'd';
                        break;

                    case 'integer':
                        $param_type .= 'i';
                        break;
                    case 'NULL':
                    case 'string':
                        $param_type .= 's';
                        break;
                    default:
                        $param_type .= 's';
                        break;
                }
            }

            return $param_type;
        }

        public static function query($sql, $params = null)
            {
                $types = self::getTypes($params);

                # create a prepared statement
                $stmt = self::$i->prepared($sql);

                # bind parameters for markers
                # but this is not dynamic enough...
                //$stmt->bind_param("s", $parameter);

                if($types&&$params)
                {
                    $bind_names[] = $types;
                    for ($i=0; $i<count($params);$i++)
                    {
                        $bind_name = 'bind' . $i;
                        $$bind_name = $params[$i];
                        $bind_names[] = &$$bind_name;
                    }
                    $return = call_user_func_array(array($stmt,'bind_param'),$bind_names);
                }

                # execute query
                $stmt->execute();

                # these lines of code below return one dimentional array, similar to mysqli::fetch_assoc()
                $meta = $stmt->result_metadata();

                while ($field = $meta->fetch_field()) {
                    $var = $field->name;
                    $$var = null;
                    $parameters[$field->name] = &$$var;
                }

                call_user_func_array(array($stmt, 'bind_result'), $parameters);

                while($stmt->fetch())
                {
                    return $parameters;
                    //print_r($parameters);
                }


                # the commented lines below will return values but not arrays
                # bind result variables
                //$stmt->bind_result($id);

                # fetch value
                //$stmt->fetch();

                # return the value
                //return $id;

                # close statement
                $stmt->close();
            }

        public static function query3($query, $a_bind_params = array())
        {

            $is_select = strtoupper(substr($query,0,6)) == "SELECT" ? true : false;

            if($is_select && count($a_bind_params) == 0)
            {
                $res = self::$i->query($query);
                $a_data = array();

                while($row = $res->fetch_assoc())
                {
                    $a_data[] = $row;
                }

                return $a_data;
            }
            else
            {
                if(count($a_bind_params) > 0)
                {

                    $a_params = array();

                    $param_type = '';

                    for($i = 0; $i < count($a_bind_params); $i++)
                    {
                        switch(gettype($a_bind_params[$i]))
                        {
                            case 'blob':
                                $param_type .= 'b';
                                break;
                            case 'double':
                                $param_type .= 'd';
                                break;

                            case 'integer':
                                $param_type .= 'i';
                                break;
                            case 'NULL':
                            case 'string':
                                $param_type .= 's';
                                break;
                            default:
                                $param_type .= 's';
                                break;
                        }
                    }

                    $param_type[] = &$param_type;

            echo "QUERY: ".$query."<br>";
            echo "TYPES: <br>";
            prettyprint($param_type);
            echo "<br>";
            echo "PARAMS (".count($a_bind_params)."): <br>";
            prettyprint($a_bind_params);

                    for($i = 0; $i < count($a_bind_params);$i++)
                    {
                        $a_params[] = $a_bind_params[$i];
                    }
                }

                $stmt = self::$i->prepare($query);

                if($stmt == false)
                {
                    return false;
                }
                call_user_func_array(array($stmt, 'bind_param'), $a_params);

                $stmt->execute();

                if($is_select)
                {
                    $a_data = array();

                    $res = $stmt->get_result();

                    while($row = $res->fetch_array(MYSQLI_ASSOC))
                    {
                      $a_data[] = $row;
                    }

                    return $a_data;
                }
                else
                {
                    return true;;
                }
            }
        }

        public static function query2($query, $params = array())
        {
            $data = array();
            $is_select = strtoupper(substr($query,0,6)) == "SELECT" ? true : false;

            if(!is_array($params))
                $params = array($params);

            $stmt = self::$i->prepare($query);

            if(!$stmt)
                return false;

            $types = "";

            foreach($params as $value)
            {
                switch(gettype($value))
                {
                    case 'blob':
                        $types .= 'b';
                        break;
                    case 'double':
                        $types .= 'd';
                        break;

                    case 'integer':
                        $types .= 'i';
                        break;
                    case 'NULL':
                    case 'string':
                        $types .= 's';
                        break;
                    default:
                        $types .= 's';
                        break;
                }
            }

            echo str_repeat("-",8)."<br>";
            echo "Query: ".$query."<br>";
            echo "Types(".strlen($types)."): ".$types."<br>";
            echo "Params(".count($params)."): ";
            prettyprint($params);
            echo str_repeat("-",8)."<br>";

            $stmt->bind_param($types, $params);
            $stmt->execute();


            if($is_select)
            {
                $res = $stmt->get_result();
                $stmt->close();

                if(!$res) return false;

                while($row = $res->fetch_array(MYSQLI_ASSOC) )
                {
                    $data[] = $row;
                }

                self::$customError = "";

                return $data;
            }
            else
            {
                return true;
            }
        }

        public static function getError() {
            return strlen(self::$customError) > 0 ? self::$customError : self::$i->error;
        }

        public static function setError($e) {
            self::$customError = $e;
        }

        public static function escape($v) {
            return self::$i->real_escape_string($v);
        }
    }