<?php
/**
 * 厦门云联储网络科技有限公司
 * https://www.baokuaiyun.com
 * Copyright (c) 2023 爆块云 All rights reserved.
 */

namespace app\models;

use Yii;
use yii\behaviors\TimestampBehavior;
use yii\db\ActiveRecord;
use yii\db\Expression;
use yii\helpers\ArrayHelper;
use yii\helpers\Json;

use app\constants\OptionSetting;

/**
 * This is the model class for table "{{%user_string_code}}".
 *
 * @property integer $id
 * @property integer $store_id
 * @property integer $user_id
 * @property integer $parent_id
 * @property integer $parent_node
 * @property string $recommend_relation
 * @property integer $layer
 * @property string $recommend_relation_node
 * @property integer $layer_node
 * @property integer $team_num
 * @property integer $area_key
 * @property integer $layer_rank
 * @property integer $created_at
 * @property integer $updated_at
 */
class UserStringCode extends \yii\db\ActiveRecord
{
    /**
     * @inheritdoc
     */
    public static function tableName()
    {
        return '{{%user_string_code}}';
    }

    public function behaviors()
    {
        return [
            [
                'class' => TimestampBehavior::class,
                'attributes' => [
                    ActiveRecord::EVENT_BEFORE_INSERT => ['created_at'],
                    ActiveRecord::EVENT_BEFORE_UPDATE => ['updated_at']
                ]
            ]
        ];
    }

    /**
     * @inheritdoc
     */
    public function rules()
    {
        return [
            [['recommend_relation', 'recommend_relation_node'], 'string'],
            [
                [
                    'store_id', 'user_id', 'parent_id', 'layer', 'layer_node', 'created_at', 'updated_at', 'parent_node',
                    'team_num', 'area_key', 'layer_rank'
                ],
                'integer'
            ],
        ];
    }

    /**
     * @inheritdoc
     */
    public function attributeLabels()
    {
        return [
            'id' => 'ID',
            'store_id' => '店铺id',
            'user_id' => '用户id',
            'parent_id' => '分销上级id',
            'parent_node' => '父节点',
            'recommend_relation_node' => '节点推荐关系',
            'layer_node' => '节点层级',
            'recommend_relation' => '分销推荐关系',
            'layer' => '分销层级',
            'area_key' => '区域Key',
            'layer_rank' => '层级排位',
            'team_num' => '团队人数',
            'created_at' => '创建时间',
            'updated_at' => '更新时间',
        ];
    }

    /**
     * 加入节点
     * @param $store_id
     * @param $user_id
     * @return bool
     */
    public static function joinNode($order)
    {
        $store_id = $order->store_id;
        $user_id = $order->user_id;
        $saas_user_id = $order->saas_id;
        // $share_setting = Option::get('share_basic_setting', $store_id);
        $share_setting = Option::get(OptionSetting::SHARE_STRING_CODE_DEFAULT_SETTING, $store_id, OptionSetting::SHARE_GROUP_NAME, '{}');
        
        $share_setting = $share_setting ? Json::decode($share_setting['value']) : [];
        if (!$share_setting) {
            //debug_log([__METHOD__, __LINE__, '加入串码节点：未开启分销设置'], "app_debug.log");
            return false;
        }
        // if (!is_array($share_setting['is_string_code']) || empty($share_setting['is_string_code']['value'])) {
        //     //debug_log([__METHOD__, __LINE__, '加入串码节点：未开启串码节点功能'], "app_debug.log");
        //     return false;
        // }
        // if (!is_array($share_setting['string_code_layer_max']) || empty($share_setting['string_code_layer_max']['value'])) {
        //     //debug_log([__METHOD__, __LINE__, '加入串码节点：未设置串码最大层级'], "app_debug.log");
        //     return false;
        // }
        // if (!is_array($share_setting['string_code_condition_coin']) || empty($share_setting['string_code_condition_coin']['value'])) {
        //     //debug_log([__METHOD__, __LINE__, '加入串码节点：未设置贡献积分条件'], "app_debug.log");
        //     return false;
        // }
        if (!is_array($share_setting['string_code_max_layer'])) {
            //debug_log([__METHOD__, __LINE__, '加入串码节点：未设置串码最大层级'], "app_debug.log");
            return false;
        }
        if (!is_array($share_setting['string_code_condition_value'])) {
            //debug_log([__METHOD__, __LINE__, '加入串码节点：未设置贡献积分条件'], "app_debug.log");
            return false;
        }
        if (!is_array($share_setting['string_code_root_user_id'])) {
            //debug_log([__METHOD__, __LINE__, '加入串码节点：未设置默认根节点'], strtolower(__CLASS__ . '.log'));
            return false;
        }

        // 判断是否满足条件
        $user = User::findOne(['id' => $user_id]);
        if ($user['total_coin'] < $share_setting['string_code_condition_value']) {
            //debug_log([__METHOD__, __LINE__, '加入串码节点：用户贡献积分不足'], "app_debug.log");
            return false;
        }
        $user_string_code = self::findOne(['user_id' => $user_id]);
        if ($user_string_code) {
            //debug_log([__METHOD__, __LINE__, "加入串码节点：用户:{$user_id}已加入串码节点"], "app_debug.log");
            return false;
        }
        // 锁定 root 节点
        if (!$user['parent_id']) {
            $parent_id = 73;
        } else {
            $parent_id = $user['parent_id'];
        }

        $parent_string_code = self::findOne(['user_id' => $parent_id]);

        list($real_parent_node, $layer_rank, $area_key) = self::getRealParentNodePlus($store_id, $user_id, $parent_id, $share_setting['string_code_max_layer']);

        if (empty($real_parent_node['recommend_relation_node'])) {
            $recommend_relation_node = ',' . $real_parent_node->user_id . ',';
        } else {
            $recommend_relation_node = $real_parent_node['recommend_relation_node'] . $real_parent_node->user_id . ',';
        }
        if (empty($parent_string_code['recommend_relation'])) {
            $recommend_relation = ',' . $parent_string_code->user_id . ',';
        } else {
            $recommend_relation = $real_parent_node['recommend_relation'] . $parent_string_code->user_id . ',';
        }

        // 保存节点数据
        $user_string_code = new self();
        $user_string_code->store_id = $store_id;
        $user_string_code->user_id = $user_id;
        $user_string_code->parent_id = $parent_id;
        $user_string_code->parent_node = $real_parent_node['user_id'];
        $user_string_code->recommend_relation_node = $recommend_relation_node;
        $user_string_code->layer_node = $real_parent_node['layer_node'] + 1;
        $user_string_code->recommend_relation = $recommend_relation;
        $user_string_code->layer = $parent_string_code['layer'] + 1;
        $user_string_code->area_key = $area_key;
        $user_string_code->layer_rank = $layer_rank;
        $user_string_code->save();

        // 保存用户区域关系
        // UserStringCodeArea::createUserStringCodeArea($store_id, $user_id, $user['parent_id'], $row, $col, $area_key);

        // 所有上级节点 团队人数 + 1
        self::setTeamCountInc($user_id);

        return true;
    }

    /**
     * 获取用户最后一个节点
     * 从左至右，从上至下
     * @param $store_id 店铺ID
     * @param $user_id 下单用户ID
     * @param $parent_id 下单用户上级ID
     * @param $max_layer 限制最大层数
     * @return array
     */
    public static function getRealParentNodePlus($store_id, $order_user_id, $parent_id, $max_layer)
    {
        // 针对父节点对应的区
        $real_area_key = 0;
        // 针对根节点对应的排序
        $real_layer_rank = 0;

        $parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $parent_id]);
        $children_list = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $parent_id]);
        // 未有子节点
        if (!$children_list) {
            //debug_log([__METHOD__, __LINE__, "未有子节点"], "app_debug.log");
            $real_parent_node = $parent_node;
            return [$real_parent_node, $real_area_key, $real_layer_rank];
        }

        // 先判断 最大层级下 第一列能否能占位
        $temp_parent_id = $parent_id;
        //debug_log([__METHOD__, __LINE__, "最大层数：{$max_layer}"], "app_debug.log");
        for ($i = 0; $i < $max_layer; $i++) {
            //debug_log([__METHOD__, __LINE__, "第1区循环：{$i}，用户ID：{$temp_parent_id}"], "app_debug.log");
            $temp_node = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $temp_parent_id, 'area_key' => $real_area_key]);
            if (!$temp_node) {
                $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $temp_parent_id]);
                return [$real_parent_node, $real_layer_rank, $real_area_key];
            } else {
                $temp_parent_id = $temp_node['user_id'];
            }
        }

        // 广度优先遍历
        $queue = [];
        $queue[] = $parent_node;
        while (!empty($queue)) {
            // 当前节点
            $current_node = array_shift($queue);
            // 当前层数
            $current_layer = $current_node['layer_node'] - $parent_node['layer_node'];
            //debug_log([__METHOD__, __LINE__, "当前节点ID：{$current_node['user_id']}，当前层数：{$current_layer}"], "app_debug.log");

            // 判断用户第1区有无落点
            $parent_first_col_auth = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $current_node['user_id'], 'area_key' => 0]);
            if (!$parent_first_col_auth) {
                $real_area_key = 0;
                //debug_log([__METHOD__, __LINE__, "当前节点ID:{$current_node['user_id']}，1区没人，落第1区"], "app_debug.log");
                $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $current_node['user_id']]);
                $current_layer_rank = UserStringCode::find()
                    ->where(['store_id' => $store_id, 'layer_node' => $real_parent_node['layer_node'] + 1])
                    ->max('layer_rank');
                $real_layer_rank = $current_layer_rank + 1;
                return [$real_parent_node, $real_layer_rank, $real_area_key];
            }

            // 判断用户能否开第2区
            $parent_second_col_auth = self::checkSecondColumnAuthPlus($store_id, $order_user_id, $current_node['user_id'], $max_layer);
            if ($parent_second_col_auth) {
                // 判断第2区第一个有无占位
                $real_area_key = 1;
                $temp_node = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $current_node['user_id'], 'area_key' => $real_area_key]);
                if (!$temp_node) {
                    //debug_log([__METHOD__, __LINE__, "当前节点ID:{$current_node['user_id']}，可开第2区，落第2区"], "app_debug.log");
                    $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $current_node['user_id']]);
                    $current_layer_rank = UserStringCode::find()
                        ->where(['store_id' => $store_id, 'layer_node' => $real_parent_node['layer_node'] + 1])
                        ->max('layer_rank');
                    $real_layer_rank = $current_layer_rank + 1;
                    return [$real_parent_node, $real_layer_rank, $real_area_key];
                }
            }

            // 判断用户能否开第3区
            $parent_multi_col_auth = self::checkMultiColumnAuth($store_id, $current_node['user_id']);
            if ($parent_multi_col_auth) {
                // 判断第3区第一个有无占位
                $real_area_key = 2;
                $temp_node = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $current_node['user_id'], 'area_key' => $real_area_key]);
                if (!$temp_node) {
                    //debug_log([__METHOD__, __LINE__, "当前节点ID:{$current_node['user_id']}，可开第3区，落第3区"], "app_debug.log");
                    $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $current_node['user_id']]);
                    $current_layer_rank = UserStringCode::find()
                        ->where(['store_id' => $store_id, 'layer_node' => $real_parent_node['layer_node'] + 1])
                        ->max('layer_rank');
                    $real_layer_rank = $current_layer_rank + 1;
                    return [$real_parent_node, $real_layer_rank, $real_area_key];
                }
            }

            // 查询当前节点的子节点（假设最多有3个子节点情况，根据实际parent_id关联查询）
            $children_nodes = UserStringCode::find()->where(['store_id' => $store_id, 'parent_node' => $current_node['user_id']])->orderBy("area_key ASC")->all();
            if ($children_nodes) {
                foreach ($children_nodes as $node) {
                    $queue[] = $node;
                }
            }
        }
    }

    public static function getRealParentNodePluss($store_id, $user_id, $max_layer)
    {
        // 针对父节点对应的区
        $real_area_key = 0;
        // 针对根节点对应的排序
        $real_layer_rank = 0;

        $parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $user_id]);
        $children_list = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $user_id]);
        // 未有子节点
        if (!$children_list) {
            //debug_log([__METHOD__, __LINE__, "未有子节点"], "app_debug.log");
            $real_parent_node = $parent_node;
            return [$real_parent_node, $real_area_key, $real_layer_rank];
        }

        // // 先判断 最大层级下 第一列能否能占位
        // $temp_parent_id = $user_id;
        // //debug_log([__METHOD__, __LINE__, "最大层数：{$max_layer}"], "app_debug.log");
        // for ($i = 0; $i < $max_layer; $i++) {
        //     //debug_log([__METHOD__, __LINE__, "第1区循环：{$i}，用户ID：{$temp_parent_id}"], "app_debug.log");
        //     $temp_node = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $temp_parent_id, 'area_key' => $real_area_key]);
        //     if (!$temp_node) {
        //         $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $temp_parent_id]);
        //         return [$real_parent_node, $real_layer_rank, $real_area_key];
        //     } else {
        //         $temp_parent_id = $temp_node['user_id'];
        //     }
        // }

        // 广度优先遍历
        $queue = [];
        $queue[] = $parent_node;
        while (!empty($queue)) {
            // 当前节点
            $current_node = array_shift($queue);
            // 当前层数
            $current_layer = $current_node['layer_node'] - $parent_node['layer_node'];
            //debug_log([__METHOD__, __LINE__, "当前节点ID：{$current_node['user_id']}，当前层数：{$current_layer}"], "app_debug.log");

            // 1 区按深度优先达到深度，再按广度遍历
            $parent_first_col_auth = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $current_node['user_id'], 'area_key' => 0]);
            if (!$parent_first_col_auth) {
                $real_area_key = 0;
                $temp_parent_id = $current_node['user_id'];
                //debug_log([__METHOD__, __LINE__, "最大层数：{$max_layer}，当前层数：{$current_layer}"], "app_debug.log");
                for ($i = 0; $i < $max_layer - $current_layer; $i++) {
                    //debug_log([__METHOD__, __LINE__, "第1区循环：{$i}，用户ID：{$temp_parent_id}"], "app_debug.log");
                    $temp_node = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $temp_parent_id, 'area_key' => $real_area_key]);
                    if (!$temp_node) {
                        //debug_log([__METHOD__, __LINE__, "当前节点ID:{$current_node['user_id']}，深度遍历1区没人，落第1区"], "app_debug.log");
                        $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $temp_parent_id]);
                        $current_layer_rank = UserStringCode::find()
                            ->where(['store_id' => $store_id, 'layer_node' => $real_parent_node['layer_node'] + 1])
                            ->max('layer_rank');
                        $real_layer_rank = $current_layer_rank + 1;
                        return [$real_parent_node, $real_layer_rank, $real_area_key];
                    }
                    $temp_parent_id = $temp_node['user_id'];
                }
                unset($temp_parent_id);
            }

            // 判断用户第1区有无落点
            // $parent_first_col_auth = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $current_node['user_id'], 'area_key' => 0]);
            // if (!$parent_first_col_auth) {
            //     $real_area_key = 0;
            //     //debug_log([__METHOD__, __LINE__, "当前节点ID:{$current_node['user_id']}，1区没人，落第1区"], "app_debug.log");
            //     $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $current_node['user_id']]);
            //     $current_layer_rank = UserStringCode::find()
            //         ->where(['store_id' => $store_id, 'layer_node' => $real_parent_node['layer_node'] + 1])
            //         ->max('layer_rank');
            //     $real_layer_rank = $current_layer_rank + 1;
            //     return [$real_parent_node, $real_layer_rank, $real_area_key];
            // }

            // 判断用户能否开第2区
            $parent_second_col_auth = self::checkSecondColumnAuthPlus($store_id, $current_node['user_id'], $max_layer);
            if ($parent_second_col_auth) {
                // 判断第2区第一个有无占位
                $real_area_key = 1;
                $temp_node = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $current_node['user_id'], 'area_key' => $real_area_key]);
                if (!$temp_node) {
                    //debug_log([__METHOD__, __LINE__, "当前节点ID:{$current_node['user_id']}，可开第2区，落第2区"], "app_debug.log");
                    $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $current_node['user_id']]);
                    $current_layer_rank = UserStringCode::find()
                        ->where(['store_id' => $store_id, 'layer_node' => $real_parent_node['layer_node'] + 1])
                        ->max('layer_rank');
                    $real_layer_rank = $current_layer_rank + 1;
                    return [$real_parent_node, $real_layer_rank, $real_area_key];
                }
            }

            // 判断用户能否开第3区
            $parent_multi_col_auth = self::checkMultiColumnAuth($store_id, $current_node['user_id']);
            if ($parent_multi_col_auth) {
                // 判断第3区第一个有无占位
                $real_area_key = 2;
                $temp_node = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $current_node['user_id'], 'area_key' => $real_area_key]);
                if (!$temp_node) {
                    //debug_log([__METHOD__, __LINE__, "当前节点ID:{$current_node['user_id']}，可开第3区，落第3区"], "app_debug.log");
                    $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $current_node['user_id']]);
                    $current_layer_rank = UserStringCode::find()
                        ->where(['store_id' => $store_id, 'layer_node' => $real_parent_node['layer_node'] + 1])
                        ->max('layer_rank');
                    $real_layer_rank = $current_layer_rank + 1;
                    return [$real_parent_node, $real_layer_rank, $real_area_key];
                }
            }

            // 查询当前节点的子节点（假设最多有3个子节点情况，根据实际parent_id关联查询）
            $children_nodes = UserStringCode::find()->where(['store_id' => $store_id, 'parent_node' => $current_node['user_id']])->orderBy("area_key ASC")->all();
            if ($children_nodes) {
                foreach ($children_nodes as $node) {
                    $queue[] = $node;
                }
            }
        }
    }

    /**
     * 广度优先遍历
     * @param $store_id
     * @param $user_id
     * @return void
     */
    public static function breadthFirstTraversal($store_id, $user_id)
    {
        $queue = [];
        $root_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $user_id]);
        $queue[] = $root_node;
        while (!empty($queue)) {
            $current_node = array_shift($queue);
            // 在这里可以对当前节点进行操作，比如输出节点的一些关键信息，以下仅输出id作为示例
            echo "当前节点ID: " . $current_node['user_id'] . "\n";
            // 查询当前节点的子节点（假设最多有3个子节点情况，根据实际parent_id关联查询）
            $children_nodes = UserStringCode::find()->where(['store_id' => $store_id, 'parent_node' => $current_node['user_id']])->all();
            if ($children_nodes) {
                foreach ($children_nodes as $node) {
                    $queue[] = $node;
                }
            }
        }
    }

    /**
     * 广度优先遍历并输出树形结构的函数
     * @param $store_id
     * @param $user_id
     * @return void
     */
    public static function breadthFirstTraversalAndPrintTree($store_id, $user_id)
    {
        $queue = [];
        $root_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $user_id]);
        $queue[] = $root_node;
        $levels = [];
        while (!empty($queue)) {
            $current_node = array_shift($queue);
            $level = $current_node['layer_node'];
            $pos = $current_node['layer_rank'];

            if (!isset($levels[$level])) {
                $levels[$level] = [];
            }

            $levels[$level][$pos] = $current_node['user_id'];

            $children_nodes = UserStringCode::find()->where(['store_id' => $store_id, 'parent_node' => $current_node['user_id']])->orderBy("area_key ASC")->all();
            if ($children_nodes) {
                foreach ($children_nodes as $node) {
                    $queue[] = $node;
                }
            }
        }

        $maxLevelWidth = max(array_map('count', $levels));
        foreach ($levels as $level => $nodes) {
            $indent = str_repeat('   ', $level);
            $line = $indent;
            foreach ($nodes as $pos => $nodeVal) {
                $line.= $nodeVal;
                if ($pos < count($nodes) - 1) {
                    $line.= '   ';
                }
            }
            $line.= str_repeat('   ', $maxLevelWidth - count($nodes));
            echo $line. "\n";
        }
    }

    /**
     * 创建 root 节点
     * @param $store_id
     * @param $user_id
     * @return bool
     */
    public static function createRootNode($store_id, $user_id)
    {
        $mode = self::findOne(['user_id' => $user_id]);
        if ($mode) {
            //debug_log([__METHOD__, __LINE__, "root 节点已存在"], "app_debug.log");
            return false;
        }
        $mode = new self();
        $mode->store_id = $store_id;
        $mode->user_id = $user_id;
        $mode->recommend_relation_node = "";
        $mode->recommend_relation = "";
        return $mode->save();
    }

    /**
     * 获取用户最后一个节点
     * 从左至右，从上至下
     * @param $store_id 店铺ID
     * @param $user_id 用户ID
     * @param $max_layer 限制最大层数
     * @return array
     */
    public static function getRealParentNode($store_id, $user_id, $max_layer)
    {
        $real_row = 0;
        $real_col = 0;
        $real_area_key = 0;

        $parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $user_id]);
        $children_list = UserStringCodeArea::findOne(['store_id' => $store_id, 'user_id' => $user_id]);
        // 未有子节点
        if (!$children_list) {
            $real_row++;
            $real_parent_node = $parent_node;
            return [$real_parent_node, $real_row, $real_col, $real_area_key];
        }

        // 先判断 最大层级下 第一列能否能占位
        for ($row = $real_row; $row <= $max_layer; $row++) {
            if ($row == 0) continue; // 0行0列是root
            $temp = UserStringCodeArea::findOne(['store_id' => $store_id, 'user_id' => $user_id, 'row' => $row, 'col' => $real_col, 'area_key' => $real_area_key]);
            if (!$temp) {
                $last_area = UserStringCodeArea::findOne(['store_id' => $store_id, 'user_id' => $user_id, 'row' => $row - 1, 'col' => $real_col, 'area_key' => $real_area_key]);
                $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $last_area['child_id']]);
                $real_row = $row;
                return [$real_parent_node, $real_row, $real_col, $real_area_key];
            }
        }

        // 用户现有最大列数
        $current_max_cols = UserStringCodeArea::find()->where(['store_id' => $store_id, 'user_id' => $user_id])->max('col');

        // 循环判断第一列 用户满足 条件（有一位直推才可以开放）第二列
        // 再判断推荐用户下第1行能否点位
        // 先深度，后横向
        $rows = $max_layer;
        $cols = $current_max_cols + 1;
        for ($r = 0; $r <= $rows; $r++) {
            if ($r = 0) {
                // root 节点
                $temp_user_id = $user_id;
                $root_second_col_auth = self::checkSecondColumnAuth($store_id, $temp_user_id, $max_layer);   // 判断用户能否开第2列
                if ($root_second_col_auth) {
                    // 判断第2列第一个有无占位
                    $root_second_node = UserStringCodeArea::findOne([
                        'store_id' => $store_id, 'user_id' => $user_id, 'row' => 1, 'col' => 1, 'area_key' => 1
                    ]);
                    if (!$root_second_node) {
                        $real_row = 1;
                        $real_col = 1;
                        $real_parent_node = $parent_node;
                        return [$real_parent_node, $real_row, $real_col, $real_area_key];
                    }
                }
                // $root_multi_col_auth = self::checkMultiColumnAuth($store_id, $temp_user_id);   // 判断用户能否开多列
            } else {
                // 子节点
                for ($c = 0; $c <= $cols; $c++) {
                    $temp_area = UserStringCodeArea::findOne(['store_id' => $store_id, 'user_id' => $user_id, 'row' => $r, 'col' => $c]);
                    if ($temp_area) {
                        $real_parent_node = UserStringCode::findOne(['store_id' => $store_id, 'user_id' => $temp_area['child_id']]);
                        $real_row = $r;
                        $real_col = $c;
                        $real_parent_node = $parent_node;
                        return [$real_parent_node, $real_row, $real_col, $real_area_key];
                    }
                }
            }
        }
    }

    /**
     * 判断用户是否能开第2列
     * @param $store_id
     * @param $user_id
     * @param $max_layer
     * @return bool
     */
    public static function checkSecondColumnAuth($store_id, $user_id, $max_layer)
    {
        $first_col_user_list = self::find()
            ->where(['store_id' => $store_id, 'user_id' => $user_id, 'col' => 1])
            ->andWhere(['<=', 'row', $max_layer])
            ->asArray()
            ->column('child_id');
        if (!$first_col_user_list) return false;
        $invite_user_ids = User::find()
            ->where(['store_id' => $store_id, 'parent_id' => $user_id])
            ->andWhere(['in', 'id', $first_col_user_list])
            ->asArray()
            ->column('id');
        if ($invite_user_ids) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断用户是否能开第2列
     * @param $store_id
     * @param $user_id
     * @param $max_layer
     * @return bool
     */
    public static function checkSecondColumnAuthPlus($store_id, $order_user_id, $user_id, $max_layer)
    {
        // $first_col_user_ids = [];
        // $temp_parent_id = $user_id;
        // for ($row = 0; $row < $max_layer; $row++) {
        //     $temp_node = self::findOne(['store_id' => $store_id, 'parent_node' => $temp_parent_id, 'area_key' => 0]);
        //     if ($temp_node) {
        //         $temp_parent_id = $temp_node['user_id'];
        //         $first_col_user_ids[] = $temp_node['user_id'];
        //     }
        // }
        // if (!$first_col_user_ids) return false;
        // $invite_user_ids = User::find()
        //     ->where(['store_id' => $store_id, 'parent_id' => $user_id])
        //     ->andWhere(['in', 'id', $first_col_user_ids])
        //     ->select('id')
        //     ->column();
        $invite_user = User::find()
            ->where(['store_id' => $store_id, 'parent_id' => $user_id])
            ->andWhere(['>=', 'total_coin', 50])
            ->andWhere(['!=', 'id', $order_user_id])
            ->one();
        if ($invite_user) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断用户是否能开多列
     * 用户股东等级大于等于V7
     * @param $store_id
     * @param $user_id
     * @return bool
     */
    public static function checkMultiColumnAuth($store_id, $user_id)
    {
        $user_holder_level = ShareHolder::find()->alias('sh')
            ->where(['sh.store_id' => $store_id, 'sh.user_id' => $user_id, 'sh.is_delete' => 0])
            ->andWhere(['sh.store_id' => $store_id, 'shl.is_delete' => 0])
            ->leftJoin(['shl' => ShareHolderLevel::tableName()], 'sh.level_id=shl.id')
            ->select('sh.user_id, shl.level')
            ->asArray()
            ->one();
        if ($user_holder_level && $user_holder_level['level'] >= 9) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 获取用户最后一个节点
     * 从左至右，从上至下
     * @param $user_id 用户ID
     * @param $layer 查找层数
     * @param $max_layer 最大层数
     * @return UserStringCode
     */
    public static function getNodePositionByParentId($user_id, $layer, $max_layer)
    {
        $last_node = self::findOne(['user_id' => $user_id]);
        $children_list = self::find()->where(['parent_id' => $user_id, 'parent_node' => $user_id])
            ->andWhere(['>=', 'area_key', 0])
            ->orderBy('area_key asc')
            ->asArray()
            ->all();
        if ($children_list) {
            $layer++;
            if ($layer <= $max_layer) {
                // 从左至右，从上至下的区域开始找
                for ($area_key = 0; $area_key < $children_list[count($children_list) - 1]['area_key']; $area_key++) {
                    $temp = self::getLastNodeByUserId($children_list[$area_key]['user_id'], $layer, $max_layer);
                    if ($temp) {
                        $last_node = $temp;
                    }
                }
            } else {
                var_dump("layer > max_layer：大于逻辑");
            }
        }
        return $last_node;
    }

    /**
     * 指定用户上级所有节点团队人数 + 1
     * @param $user_id
     * @return int
     */
    public static function setTeamCountInc($user_id)
    {
        $parent_node_ids = self::getAllParentNodeIds($user_id);
        if ($parent_node_ids) {
            return self::updateAll(
                ['team_num' => new Expression('team_num + 1')],
                ['in', 'user_id', $parent_node_ids]
            );
        } else {
            return 0;
        }
    }

    /**
     * 获取节点用户最大可开通区域
     * @param $user_id
     * @return int
     */
    public static function getMaxAreaKeyByUserId($user_id)
    {
        $user_node = self::findOne(['user_id' => $user_id]);
        return $user_node['area_key'];
    }

    public static function getAllParentIds($user_id)
    {
        $relation = self::findOne(['user_id' => $user_id]);
        $recommon_relation = trim($relation['recommend_relation'], ',');
        if (!$recommon_relation) return [];
        return explode(',', $recommon_relation);
    }

    public static function getAllParentNodeIds($user_id)
    {
        $relation = self::findOne(['user_id' => $user_id]);
        $recommon_relation_node = trim($relation['recommend_relation_node'], ',');
        if (!$recommon_relation_node) return [];
        return explode(',', $recommon_relation_node);
    }

    public static function getChildNodeIdsByUserId($user_id, $node_key = '', $level = 0, $scope = 'all')
    {
        $user_node = self::find()->select(['layer_node'])->where(['user_id' => $user_id])->asArray()->one();
        $layer_node = (int)$user_node['layer_node'];
        $query = self::find()->select(['user_id'])->where(['like', 'recommend_relation_node', (',' . $user_id . ',')]);
        if ($node_key) $query->andWhere(['node_key' => $node_key]);
        //查询多N代全部子用户
        if ($level > 0 && $scope == 'all') $query->andWhere(['>=', 'layer_node', $level + $layer_node]);
        //查询指定代子用户
        if ($level > 0 && $scope == 'equal') $query->andWhere(['=', 'layer_node', $level + $layer_node]);
        return $query->asArray()->column();
    }

    /**
     * 查询用户指定部门的所有用户 ids
     * @param $user_id
     * @param $node_key
     * @return array
     */
    public static function getChildNodeIdsByAreaKey($store_id, $user_id, $area_key)
    {
        $child_ids = [];

        $queue = [];
        $root_node = UserStringCode::findOne(['store_id' => $store_id, 'parent_node' => $user_id, 'area_key' => $area_key]);
        $queue[] = $root_node;
        while (!empty($queue)) {
            $current_node = array_shift($queue);
            $children_nodes = UserStringCode::find()->where(['store_id' => $store_id, 'parent_node' => $current_node['user_id']])->all();
            if ($children_nodes) {
                foreach ($children_nodes as $node) {
                    $queue[] = $node;
                }
            }
            $child_ids[] = $current_node['user_id'];
        }
        return $child_ids;
    }

    public static function getAllParentList($user_id)
    {
        $relation = self::findOne(['user_id' => $user_id]);
        $recommon_relation = trim($relation['recommend_relation'], ',');
        $relation_arr = explode(',', $recommon_relation);
        if (empty($relation_arr)) {
            return [];
        }

        $list = Share::find()->alias('s')->where(array('in', 's.user_id', $relation_arr))
            ->andWhere(['sl.is_delete' => 0])
            ->leftJoin(['sl' => ShareLevel::tableName()], 'sl.level=s.level')
            ->select('s.user_id, sl.order_layer, sl.point_reward')
            ->asArray()
            ->all();
        if (empty($list)) {
            return [];
        }

        $level_list = ArrayHelper::index($list, "user_id");

        $res = [];
        foreach ($relation_arr as $v) {
            $temp = [];
            $temp['user_id'] = $v;
            $temp['order_layer'] = $level_list[$v]['order_layer'] ?? 0;
            $temp['point_reward'] = $level_list[$v]['point_reward'] ?? 0;
            $temp['is_bonus'] = isset($level_list[$v]);
            $res[] = $temp;
        }

        return $res;
    }

    public static function getAllParentNodeList($user_id)
    {
        $relation = self::findOne(['user_id' => $user_id]);
        $recommon_relation_node = trim($relation['recommend_relation_node'], ',');
        $relation_arr = explode(',', $recommon_relation_node);
        if (empty($relation_arr)) {
            return [];
        }

        $list = Share::find()->alias('s')->where(array('in', 's.user_id', $relation_arr))
            ->andWhere(['sl.is_delete' => 0])
            ->leftJoin(['sl' => ShareLevel::tableName()], 'sl.level=s.level')
            ->select('s.user_id, sl.order_layer, sl.point_reward')
            ->asArray()
            ->all();
        if (empty($list)) {
            return [];
        }

        $level_list = ArrayHelper::index($list, "user_id");

        $res = [];
        foreach ($relation_arr as $v) {
            $temp = [];
            $temp['user_id'] = $v;
            $temp['order_layer'] = $level_list[$v]['order_layer'] ?? 0;
            $temp['point_reward'] = $level_list[$v]['point_reward'] ?? 0;
            $temp['is_bonus'] = isset($level_list[$v]);
            $res[] = $temp;
        }

        return $res;
    }

    public static function getRecommendRelationByUserId($user_id)
    {
        $res = "";
        $parentList = [];
        self::getParentList($user_id, $parentList);
        if ($parentList) {
            $res = "," . implode(',', array_reverse($parentList)) . ",";
        }
        return $res;
    }

    public static function getParentList($user_id, &$parentList)
    {
        $user = User::findOne(['id' => $user_id]);
        if ($user['parent_id']) {
            $parentList[] = $user['parent_id'];
            $parent = User::findOne(['id' => $user['parent_id']]);
            if ($parent) {
                return self::getParentList($parent['id'], $parentList);
            }
        }
        return $parentList;
    }

    public static function getLayerByUserId($user_id)
    {
        $res = 1;
        $parentList = [];
        self::getParentList($user_id, $parentList);
        if ($parentList) {
            $res += count($parentList);
        }
        return $res;
    }

    public static function createUserNode($store_id, $user_id)
    {
        $user_node = self::findOne(['user_id' => $user_id]);
        if (!$user_node) {
            $user = User::findOne(['id' => $user_id]);

            $user_node = new self();
            $user_node->store_id = $store_id;
            $user_node->user_id = $user_id;
            $user_node->parent_id = $user['parent_id'];
            $user_node->recommend_relation = self::getRecommendRelationByUserId($user_id);
            $user_node->layer = self::getLayerByUserId($user_id);
            $user_node->recommend_relation_node = "";
            $user_node->layer_node = 0;
            $user_node->created_at = time();
            if (!$user_node->save()) {
                //debug_log([__METHOD__, __LINE__, "用户：{$user_id}，节点信息保存失败"], "app_debug.log");
            }
        }
        return $user_node;
    }

    public static function getChildNodeCount($user_id)
    {
        $node_count = self::find()->select('team_num')->where(['user_id' => $user_id])->scalar();
        return (int)$node_count;
    }

    /**
     * 获取用户节点团队业绩
     * @param $user_id
     * @return false|int|string|null
     */
    public static function getTeamNodeOrderPrice($user_id)
    {
        $child_ids = self::getChildNodeIdsByUserId($user_id);
        $team_ids = array_merge($child_ids, [$user_id]);
        return User::find()->select('SUM(`total_coin`) as node_order_price')->where(['in', 'id', $team_ids])->scalar();
    }

    /**
     * 获取用户部门列表
     * @param $user_id
     * @return array
     */
    public static function getUserDepartmentList($store_id, $user_id)
    {
        $user = User::findOne(['id' => $user_id]);
        $user_share_holder_level = ShareHolder::findOne(['user_id' => $user_id]);

        if ($user['total_coin'] < 50) {
            // 未消费大礼包只有A部门
            $area_key_highest = 0;
        } else {
            // 有消费则有A,B等多部门
            if ($user_share_holder_level['level_id'] < 9) {
                // 股东等级小于V7只有A,B两条线
                $area_key_highest = 1;
            } else {
                // 大于等于V7可开多线
                $area_key_highest = self::getLastNodeKeyByUserId($user_id) + 1;
            }
        }

        $res = [];
        for ($area_key = 0; $area_key <= $area_key_highest; $area_key++) {
            $last_user_id = self::getLastUserByDepartmentKey($store_id, $user_id, $area_key);
            $last_user = User::findOne(['id' => $last_user_id]);
            $department_name = $area_key + 1;
            $temp = [];
            $temp['id'] = $area_key;
            $temp['department_key'] = $area_key;
            $temp['user_id'] = $last_user_id;
            $temp['department_name'] = "{$department_name}-部门";
            $temp['nickname'] = $last_user['nickname'];
            $temp['mobile'] = $last_user['binding'];
            $res[] = $temp;
        }

        return $res;
    }

    /**
     * 获取指定用户最高部门 node_key
     * @param $user_id
     * @return int|mixed
     */
    public static function getLastNodeKeyByUserId($user_id)
    {
        $last_node_key = 0;
        $node_list = self::find()
            ->where(['parent_id' => $user_id])
            ->orderBy('node_key DESC')
            ->asArray()
            ->one();
        if ($node_list) {
            $last_node_key = $node_list['node_key'];
        }
        return $last_node_key;
    }

    /**
     * 获取指定用户的部门最后一个用户
     * @param $user_id
     * @param $department_name
     * @return int
     */
    public static function getLastUserByDepartmentKey($store_id, $user_id, $area_key)
    {
        $child_ids = self::getChildNodeIdsByAreaKey($store_id, $user_id, $area_key);
        return $child_ids[count($child_ids) - 1];
    }

    public static function getLastParentNodeLeader($user_id)
    {
        $user_node = self::findOne(['user_id' => $user_id]);
        if ($user_node->parent_id == $user_node->parent_node) {
            return self::findOne(['user_id' => $user_node->parent_id]);
        } else {
            return self::getLastParentNodeLeader($user_node->parent_node);
        }
    }

    /**
     * 获取用户区域列表
     * @param $user_id
     * @return void
     */
    public static function getAreaList($user_id)
    {

    }

}