<?
namespace ms;

use core\db\structure\Column as C;
use core\db\structure\eColumnType;
use ui\form\structure\eInputType;
use ui\Form;
use ui\input\Input;
use core\lang\structure\LangVariable as V;
use ms\ms\structure\msModuleTable;
use ms\table\structure\msTableLang as Vars;


class Table extends msModuleTable {
    static $self;
    static $table_name = 'msTable';
    static $controller  = 'ms.table';

    static $ID       = 'id';
    static $NAME     = 'name';

    static $COLUMNS  = 'columns';
    static $DATA     = 'data';
    static $CLASS    = 'class';

    static $ACCOUNT  = 'account';
    static $CREATED  = 'created';
    static $UPDATED  = 'updated';

    public function _update(\Where $w, array $values) {
        $values[self::$UPDATED] = time();
        return parent::_update($w, $values);
    }

    static function add($values){
        $dupl = [];
        if($v = $values[$k = self::$COLUMNS]) $dupl[$k] = $v;
        if($v = $values[$k = self::$DATA])    $dupl[$k] = $v;
        if($v = $values[$k = self::$CLASS])   $dupl[$k] = $v;

        self::insert($values,[\Query::ON_DUPLICATE_KEY_UPDATE=>$dupl]);
    }

    public static function installUniques() {
        \DB::addUnique(self::$table_name,self::$table_name.'_unique',[self::$NAME,self::$ACCOUNT]);
    }
    static function setData($name,$values){
        $cols = self::getMyByName($name);
        if($cols) {
            $data = ($c = json_decode($cols[self::$DATA],true))?$c:[];
            foreach ($values as $k=>$v){
                $data[$k] = $v;
            }
            self::add([
                self::$NAME=>$name,
                self::$DATA=>json_encode($data),
            ]);
        }
    }

    static function setColumnWidth($name,$column,$width){
        $cols = self::getMyByName($name);
        if($cols) {
            $data = json_decode($cols[self::$COLUMNS],true);
            $data[$column]['width'] = $width;
            self::add([
                self::$NAME=>$name,
                self::$COLUMNS=>json_encode($data),
            ]);
        }
    }


    static function getMyByName($name){
        $r = self::select([
            \Query::WHERE=>new \Where(\Where::_and([
                \Where::_operator(self::$ACCOUNT,'=',UID),
                \Where::_operator(self::$NAME,'=',$name),
            ]))
        ],true);
        return count($r)?array_pop($r):null;
    }


    static function getSettings($name,$controller=''){
        $C = self::getMyByName($name);
        $res = $C?json_decode($C[self::$DATA],true):[];
        $res[\ModuleTable::TABLE_ID] = $name;
        $res['class'] = $C[self::$CLASS];
        $res['_table_settings'] = true;
        if(!$C and $controller){
            $controller = \Core::prepareModuleName($controller);
            self::add([
                self::$NAME=>$name,
                self::$CLASS=>$controller,
            ]);
            $res['class'] = $controller;
        }
        return $res;
    }

    static function getMyWidth($name){
        $res  = [];
        $cols = self::getMyByName($name);
        $data = json_decode($cols[self::$COLUMNS],true);
        foreach ($data as $k=>$v){
            $res[$k] = $v['width'];
        }
        return $res;
    }

    static function getMyColumns($name,$class){
        $class = \Core::prepareModuleName($class);
        $info = $class::getColumns();
        $res = [];
        /*
        $cols = self::getMyByName($name);
        if($cols) {
            $data = json_decode($cols[self::$COLUMNS],true);
            foreach ($data as $k=>$v) {
                $res[$k] = $info[$k];
            }
            foreach ($info as $k=>$v) {
                if(!isset($res[$k]) and !$v->isHidden())
                    $res[$k] = $info[$k];
            }
        }
        */
        if(!$res) {
            $res = $info;
            $columns = [];
            foreach ($info as $k=>$v) {
                $columns[$k] = ['width'=>'min-content'];
            }
            self::add([
                self::$NAME=>$name,
                self::$COLUMNS=>json_encode($columns),
            ]);
        }
        foreach($res as $k=>$v){
            if(!$v) {
                unset($res[$k]);
                continue;
            }
            if($v->isHidden()) unset($res[$k]);
        }
        return $res;

    }

    static function columnInfo() : array {
        return [
            new C([
                C::VAR_NAME         =>&self::$ID,
                C::TYPE             =>eColumnType::INT,
                C::AUTO_INCREMENT   =>true,
                C::PRIMARY          =>true,
                C::DEFAULT          =>0,
                C::HIDDEN           =>true,
                C::TH               =>V::get(Vars::$ID),
            ]),
            new C([
                C::VAR_NAME         => &self::$NAME,
                C::TYPE             => eColumnType::VARCHAR,
                C::LENGTH           => 127,
                C::TH               => V::get(Vars::$NAME),
            ]),
            new C([
                C::VAR_NAME         => &self::$CLASS,
                C::TYPE             => eColumnType::VARCHAR,
                C::LENGTH           => 63,
            ]),
            new C([
                C::VAR_NAME         => &self::$DATA,
                C::TYPE             => eColumnType::TEXT,
                C::DEFAULT          => '{}',
                //C::TH               => V::get(Vars::$DATA),
            ]),
            new C([
                C::VAR_NAME         => &self::$COLUMNS,
                C::TYPE             => eColumnType::TEXT,
            ]),
            new C([
                C::VAR_NAME         => &self::$ACCOUNT,
                C::TYPE             => eColumnType::INT,
                C::LENGTH           => 11,
                C::TH               => V::get(Vars::$ACCOUNT),
                C::DEFAULT          => intval(UID),
                //c::HIDDEN=>true,

                c::FUNC_VALUE       => function($v){
                    if($id = $v[self::$ACCOUNT]) {
                        return \Account::getName(  \Account::getByID($id) );
                    } else return '-';
                },
            ]),
            new C([
                C::VAR_NAME         => &self::$CREATED,
                C::TYPE             => eColumnType::INT,
                C::LENGTH           => 11,
                C::TH               => V::get(Vars::$CREATED),
                C::DEFAULT          => time(),
                c::FUNC_VALUE       => function($v){return self::formatDate($v[self::$CREATED]);},
                c::HIDDEN=>true,
            ]),
            new C([
                C::VAR_NAME         => &self::$UPDATED,
                C::TYPE             => eColumnType::INT,
                C::DEFAULT          => time(),
                C::TH               => V::get(Vars::$UPDATED),
                c::FUNC_VALUE       => function($v){return self::formatDate($v[self::$UPDATED]);},
                c::HIDDEN=>true,
            ]),
        ];
    }

}
new Table();