<?
namespace shop\item;

use core\db\structure\Column as C;
use core\db\structure\eColumnType;
use ms\MS;
use ms\ms\structure\msLang;
use shop\core\structure\shopModuleTable;
use shop\item\structure\eShopItemPriceType;
use shop\Property;
use shop\property\structure\ePropertyType;
use ui\form\structure\eInputType;
use ui\Form;
use ui\input\Input;
use core\lang\structure\LangVariable as V;
use shop\item\value\structure\shopItemValueLang as Vars;
use shop\property\Value as PropertyValue;
use shop\Item;


class Value extends shopModuleTable {
    static $self;
    static $table_name = 'shopItemValue';
    static $controller  = 'shop.item.value';

    static $ID         = 'id';
    static $ITEM       = 'item';
    static $PROPERTY   = 'property';
    static $TEXT       = 'text';
    static $VALUE      = 'value';
    static $PRICE      = 'price';
    static $IS_DEFAULT = 'is_default';
    static $ACCOUNT    = 'account';
    static $CREATED    = 'created';
    static $UPDATED    = 'updated';

    static $easy_left_joins = [];

    public function __construct($install_id = null) {
        parent::__construct($install_id);
        self::$easy_left_joins = [
            [Property::$table_name,self::$PROPERTY,Property::$ID],
            [PropertyValue::$table_name,self::$VALUE,PropertyValue::$ID],
        ];
    }

    public static function installUniques() {
        \DB::addIndex(self::$table_name,self::$PROPERTY);
        \DB::addIndex(self::$table_name,self::$ITEM);
        \DB::addIndex(self::$table_name,self::$VALUE);
        \DB::addIndex(self::$table_name,self::$ACCOUNT);
    }


    static function getTitle(){return V::get(Vars::$MODULE_NAME);}
    static function getSystemLangValues():array{ return Vars::getArray(); }
    public function _update(\Where $w, array $values) {
        $values[self::$UPDATED] = time();
        return parent::_update($w, $values);
    }

    static function getValue($v){
        switch ($v[Property::$TYPE]) {
            case ePropertyType::VALUES_MANY:
            case ePropertyType::VALUES_ONE:
                return PropertyValue::getName( $v );
                break;
            default: return h($v[self::$TEXT]);
        }
    }
    static function getValueForReact($v){
        switch ($v[Property::$TYPE]) {
            case ePropertyType::VALUES_MANY:
            case ePropertyType::VALUES_ONE:
                return $v[self::$VALUE];
                break;
            default: return h($v[self::$TEXT]);
        }
    }


    public static function afterUadd($values, $id, $result) {
        $res = parent::afterUadd($values, $id, $result);

        if(isset($values['react_values'])){
            $item_id = intval($values[self::$ITEM]);
            if($item_id) {
                self::delete(new \Where(\Where::_and([
                        \Where::_operator(self::$ACCOUNT, '=', UID),
                        \Where::_operator(self::$ITEM, '=', $values[self::$ITEM]),
                    ]))
                );
                foreach ($values['values'] as $prop_id => $values) {
                    $prop_id = intval($prop_id);
                    $prop = Property::getByID($prop_id);
                    foreach ($values as $v){
                        $o = [
                            self::$PROPERTY   => $prop_id,
                            self::$ITEM       => $item_id,
                            self::$PRICE      => je($v['price']),
                            self::$IS_DEFAULT => (boolval($v['is_default'])?1:0),
                        ];
                        switch ($prop[Property::$TYPE]){
                            case ePropertyType::VALUES_ONE:
                            case ePropertyType::VALUES_MANY:
                                $o[self::$VALUE] = intval($v['value']);
                                break;
                            default:
                                $o[self::$TEXT] = $v['value'];
                                break;
                        }
                        self::insert($o);
                    }
                }
            }
        } else {
            $prop = Property::getByID($values[self::$PROPERTY]);
            switch (intval($prop[Property::$TYPE])) {
                case ePropertyType::VALUES_MANY:

                    if ($prop_id = intval($prop[Property::$ID]) and $item_id = intval($values[self::$ITEM])) {
                        self::delete(new \Where(\Where::_and([
                                \Where::_operator(self::$PROPERTY, '=', $prop[Property::$ID]),
                                \Where::_operator(self::$ACCOUNT, '=', UID),
                                \Where::_operator(self::$ITEM, '=', $values[self::$ITEM]),
                            ]))
                        );
                        if (!is_array($values[self::$VALUE])) $values[self::$VALUE] = [$values[self::$VALUE]];
                        foreach ($values[self::$VALUE] as $v) {
                            if ($C = PropertyValue::isMy($v)) {
                                self::insert([
                                    self::$PROPERTY => $prop_id,
                                    self::$VALUE => $C[PropertyValue::$ID],
                                    self::$ITEM => $item_id,
                                ]);
                            }
                        }
                        break;
                    }
            }
        }

        return $res;
    }


    static function getByItem($item_id,$isAssocArray = true){
        $r =  self::select([
            \Query::WHERE => new \Where(\Where::_and([
                \Where::_operator(self::$ITEM,'=',$item_id),
            ]))
        ],$isAssocArray);
        return $r;
    }
    static function getByItemPropertyID($item_id,$property_id,$isAssocArray = true){
        $r =  self::select([
            \Query::WHERE => new \Where(\Where::_and([
                \Where::_operator(self::$PROPERTY,'=',$property_id),
                \Where::_operator(self::$ITEM,'=',$item_id),
            ]))
        ],$isAssocArray);
        return $r;
    }


    static function getByPropertyID($id,$isAssocArray = true){
        return self::select([
            \Query::WHERE => new \Where(\Where::_operator(self::$PROPERTY,'=',$id))
        ],$isAssocArray);
    }

    static function getPropertyIdsForItem($id){
        $res = [];
        $r = Value::select([
            \Query::SELECT => 'distinct '.Value::$PROPERTY,
            \Query::WHERE  => new \Where(\Where::_operator(Value::$ITEM,'=',$id))
        ],false);
        while($l = \DB::fetch($r)){
            $res[] = $l[Value::$PROPERTY];
        }
        return $res;
    }
    static function getForm($values = [],  $options = []) :array {
        $or = [];
        $property = null;
        if($pids = self::getPropertyIdsForItem($values[self::$ITEM])) $or[] = $pids;
        if($property_id = intval($values[self::$PROPERTY])) {
            //$or[] = $property_id;
            $property = Property::getByID($property_id);
        }

        if(boolval($values['react'])){
            $data = Property::getStructureForReactInput();

            $ITEM = Item::getByID(intval($values[self::$ITEM]));
            $ITEM_ID = $ITEM[Item::$ID];
            $_vals = self::getByItem($ITEM_ID);
            $vals = [];
            foreach ($_vals as $id=>$v){
                $vals[$v[Value::$PROPERTY]][] = [
                    'id'         => $v[self::$ID],
                    'title'      => self::getValue($v),
                    'value'      => self::getValueForReact($v),
                    'price'      => json_decode($v[self::$PRICE]),
                    'is_default' => boolval($v[self::$IS_DEFAULT]),
                ];
            }


            /*
            switch ($ITEM[Item::$PRICE_TYPE]){
                case eShopItemPriceType::COMPONENT_LIST
            }
            /**/


            $res = [
                [
                    Form::VIEW => Form::ROW,
                    Form::ROW_CLASSES=>' row',
                    Form::COLS => [
                        [
                            Form::VIEW          =>Form::INPUT,
                            Form::COL_CLASSES   =>'',
                            Form::TYPE          =>eInputType::SUBMIT_AND_CLOSE,
                            Form::INPUT_OPT   => [
                                Input::CSS_CLASS => MS::CSS_BTN_SAVE_AND_CLOSE,
                                Input::LABEL     => $c = V::get(msLang::$BUTTON_SUBMIT_AND_CLOSE),
                            ],
                        ],
                    ]
                ],
                self::getCommonFormInputs(),
                [
                    Form::VIEW => Form::INPUT,
                    Form::KEY_VALUE => self::$ITEM,
                    Form::TYPE => eInputType::HIDDEN,
                ],
                [
                    Form::VIEW => Form::INPUT,
                    Form::KEY_VALUE => 'react_values',
                    Form::TYPE => eInputType::HIDDEN,
                    Form::INPUT_OPT => [
                        Input::VALUE=>1,
                    ],
                ],
                [
                    Form::VIEW => Form::INPUT,
                    Form::TYPE => eInputType::SHOP_ITEM_VALUES,
                    Form::KEY_VALUE => 'values',
                    Form::INPUT_OPT => [
                        Input::OPTIONS => $data,
                        Input::VALUE   => [
                            'vals'=>$vals,
                            'price_type'=>$ITEM[Item::$PRICE_TYPE],
                        ],
                    ]
                ],
            ];
        } else {
            $res = [
                self::getCommonFormInputs(),
                [
                    Form::VIEW => Form::INPUT,
                    Form::KEY_VALUE => self::$ITEM,
                    Form::TYPE => eInputType::HIDDEN,
                ],
                [
                    Form::VIEW => Form::ROW,
                    Form::COLS => [
                        $property_id ? [
                            Form::VIEW => Form::TITLE,
                            Form::TITLE_TEXT => Property::getName($property),
                        ] : null,
                        $property_id ? [
                            Form::VIEW => Form::INPUT,
                            Form::KEY_VALUE => self::$PROPERTY,
                            Form::TYPE => eInputType::HIDDEN,
                        ] : [
                            Form::VIEW => Form::INPUT,
                            Form::COL_CLASSES => 'col-12',
                            Form::KEY_VALUE => self::$PROPERTY,
                            Form::TYPE => eInputType::SELECT_SEARCH,
                            Form::INPUT_OPT => [
                                Input::PLACEHOLDER => $c = V::get(Vars::$PROPERTY),
                                Input::LABEL => $c,
                                Input::OPTIONS => Property::getNameList([
                                    \Query::WHERE => $w = new \Where(
                                        \Where::_and([
                                            \Where::_operator(Property::$ACCOUNT, '=', UID),
                                            $or ?
                                                \Where::_or([
                                                    \Where::_operator(Property::$ID, '=', $values[self::$PROPERTY]),
                                                    $pids ? \Where::_not([\Where::_in(Property::$ID, $pids)]) : null,
                                                ])
                                                : null
                                        ])
                                    )
                                ])
                            ],
                        ],
                    ]
                ],
                [
                    Form::VIEW => FORM::INPUT,
                    Form::TYPE => eInputType::SCRIPT,
                    Form::INPUT_OPT => [
                        Input::VALUE => '$.fn.ITEM(\'initChangingProperty\')',
                    ],
                ],
                [
                    Form::VIEW => FORM::INPUT,
                    Form::TYPE => eInputType::HTML,
                    Form::INPUT_OPT => [
                        Input::VALUE => '<div class="loaded_values"></div>',
                    ],
                ],
                self::getCommonFormSubmits($values),
            ];
        }
        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::$ITEM,
                C::TYPE             => eColumnType::INT,
                C::LENGTH           => 11,
                C::TH               => V::get(Vars::$ITEM),
                C::HIDDEN           => true,
            ]),
            new C([
                C::VAR_NAME         => &self::$PROPERTY,
                C::TYPE             => eColumnType::INT,
                C::LENGTH           => 11,
                C::TH               => V::get(Vars::$PROPERTY),
                C::FUNC_VALUE       => function($v){
                    return Property::getName( $v );
                },
                C::FUNC_VALUE_DATA  => function($v){
                    return Property::getName($v);
                }
            ]),
            new C([
                C::VAR_NAME         => &self::$PRICE,
                C::TYPE             => eColumnType::TEXT,
                C::HIDDEN           => true,
            ]),
            new C([
                C::VAR_NAME         => &self::$TEXT,
                C::TYPE             => eColumnType::VARCHAR,
                C::LENGTH           => 255,
                C::HIDDEN           => true,
            ]),
            new C([
                C::VAR_NAME         => &self::$IS_DEFAULT,
                C::TYPE             => eColumnType::TINYINT,
                C::DEFAULT          => 0,
                C::HIDDEN           => true,
            ]),
            new C([
                C::VAR_NAME         => &self::$VALUE,
                C::TYPE             => eColumnType::VARCHAR,
                C::LENGTH           => 255,
                C::TH               => V::get(Vars::$VALUE),
                C::FUNC_VALUE       => function($v){
                    return self::getValue($v);
                },
                C::FUNC_VALUE_DATA  => function($v){
                    return self::getValue($v);
                }
            ]),
            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 Value();


///