<?php

namespace loyalsoft;

//require_once __DIR__ . '/ActiveProc/Lotterys.php';
//require_once __DIR__ . '/ActiveProc/Boxes.php';
require_once __DIR__ . '/ActiveProc/Day7Tasks.php';
require_once __DIR__ . '/ActiveProc/CipheredBase32.php';

/**
 * 活动模块
 */
class ActiveProc {

    /**
     * 兑换码礼包使用记录
     */
    const tab_toke_gift = 'tab_token_gift';

    /**
     * 逻辑分发
     * 所有的Proc中必须有这样一个方法
     * @param Req $req
     */
    public static function procMain($req) {
        switch ($req->cmd) {
            case CmdCode::active_day7_gettasklist:                              # 6500 刷新任务状态
                return Day7Tasks::Day7_RefreshTaskList($req);
            case CmdCode::active_day7_completetask:                             # 6501 完成任务
                return Day7Tasks:: Day7_CompleteTask($req);
            case CmdCode::active_day7_drawreward:                               # 6502 领取奖励
                return Day7Tasks::Day7_DrawReward($req);
            case CmdCode::active_getzonePublicTs:                               # 6503 查询开服时间戳
                return ActiveProc::GetZonePublicTS($req);
            case CmdCode::Task_completetask:                                    # 6506 完成任务
                return ActiveProc::Tasks_CompleteTask($req);
            case CmdCode::Task_drawreward:                                      # 6507 领取奖励
                return ActiveProc::Tasks_DrawReward($req);
            case CmdCode::Task_Tili:                                            # 6508 体力变化
                return ActiveProc::RecoveryTili($req);
//            case CmdCode::lottery:                                              # 6509 抽奖
//                return Boxes::OpenBox($req);                                    # 宝箱
//                return Lotterys::Lottery($req);
//                return Lotterys::Lottery_Hero($req);
//            case CmdCode::lottery_demo:                                         # 6510 新手引导: 抽奖
//                return Lotterys::demoLottery($req);
//            case CmdCode::lottery_baodi:                                        # 6511 抽奖 - 保底奖励
//                return Lotterys::baodiLottery($req);
            case CmdCode::active_token_drawReward:                              # 6512 兑换码礼包
                return self::drawActivePackageByCode($req);
            case CmdCode::active_draw_onlinegift:                               # 6513 领取在线礼包
                return self::drawOnlineGift();
            case CmdCode::active_draw_reggift:                                  # 6514 领取全服注册礼包
                return self::drawRegGift($req);
            case CmdCode::active_presentTili:                                   # 6515 领取在线赠送体力
                return self::drawTiliGift($req);
            case CmdCode::active_get_regnum:                                    # 6516 查询当前全服注册人数
                return self::getRegNumber($req);

            default:
                return Resp::err(ErrCode::cmd_err);
        }
    }

// <editor-fold defaultstate="collapsed" desc="    赠送体力    ">

    /**
     * 领取 赠送体力
     * @param Req $req
     * @return type
     */
    static function drawTiliGift($req) {
        $user = new UserGameModel($req->userInfo->game);
        $privateState = new PrivateStateModel($user->privateState);
        $hour = date('G');
        if (in_array($hour, $privateState->dailyDrawedTiliGift)) {              # 判断是否已领取
            return Resp::err(ErrCode::active_hasgetted);
        }
        $arr = explode(',', glc()->activity_presentTili_times);                 # 判断是否满足领取条件
        if (!in_array($hour, $arr)) {
            return Resp::err(ErrCode::active_illegal);              # 不满足条件
        }
        UserGameModel::Add_tili($req, glc()->activity_presentTili_number); # 发放奖励

        $privateState->dailyDrawedTiliGift[] = $hour;
        $req->userInfo->game->privateState = $privateState;
        UserProc::updateUserInfo();                                         # 回存
        return Resp::ok(array(#                                     # 返回值
                    'key' => 'ok',
                    'record' => $privateState->dailyDrawedTiliGift,
                    'tili' => $req->userInfo->game->tili,
                    'time' => $req->userInfo->game->privateState->TiliTime,
        ));
    }

////
// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="    全服注册礼包    ">

    /**
     * 查询当前全服注册人数
     * @param type $req
     */
    static function getRegNumber($req) {
        return Resp::ok(array(
                    'num' => gMem()->get(MemKey_GameRun::Stat_UserCountByZone_int($req->zoneid))
        ));
    }

    /**
     * 领取全服注册礼包
     * @param Req $req
     */
    static function drawRegGift($req) {
        $user = new UserGameModel($req->userInfo->game);
        $privateState = new PrivateStateModel($user->privateState);
        $giftId = $req->paras[0];                                               # 礼包id
        $giftModel = GameConfig::activity_reggift_getItem($giftId);             # 取礼包常亮数据
        if (null == $giftModel) {
            return Resp::err(ErrCode::err_const_no);
        }
        if (in_array($giftId, $privateState->drawedRegGift)) {                  # 判断是否已领取
            return Resp::err(ErrCode::active_hasgetted);
        }
        // 判断是否满足领取条件
        if (gMem()->get(MemKey_GameRun::Stat_UserCountByZone_int($req->zoneid)) < $giftModel->regNumber) {
            return Resp::err(ErrCode::active_illegal);              # 不满足条件
        }
        $err = StoreProc::AddMultiItemInStore($req, $giftModel->rewardstr);     # 发放奖励
        if ($err) {
            return Resp::err($err);                                 # 失败
        }
        $privateState->drawedRegGift[] = $giftId;
        $user->privateState = $privateState;
        $req->userInfo->game = $user;
        UserProc::updateUserInfo();                                         # 回存
        return Resp::ok(array(#                                     # 返回值
                    'key' => 'ok',
                    'store' => $req->userInfo->game->store
        ));
    }

// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="    在线礼包   ">

    /**
     * 6513 领取连续在线礼包
     * @return type
     */
    static function drawOnlineGift() {
        $req = req();
        $user = $req->userInfo->game;
        $privateState = new PrivateStateModel($user->privateState);
        $giftid = $req->paras[0];                                               # 提取参数: 礼包的编号
        $giftData = GameConfig::activity_onlinegift_getItem($giftid);           # 在线礼包常量数据
        if ($giftData == NULL) {
            return Resp::err(ErrCode::onlinegift_constno_err);
        }
        if ($privateState->onlineGiftts + $giftData->onlineSec > now()) {       # 时间未到，不可以领取
            return Resp::err(ErrCode::onlinegift_timenotenough);
        }
        if (!CommUtil::isPropertyExists($privateState, "onlineGiftID")) {#初始化 这个字段
            $privateState->onlineGiftID = 1;
        } else {
            if ($privateState->onlineGiftID == 0) {
                $privateState->onlineGiftID = 1;
            }
        }

        if ($privateState->onlineGiftID != $giftid) {                           # 判断礼包ID是否正确，可以领取，
            return Resp::err(ErrCode::onlinegift_wrongid, $privateState->onlineGiftID . '--->' . $giftid);
        }

        $privateState->onlineGiftts = now();                                    # 更新时间戳
        $privateState->onlineGiftID = $giftid + 1;                              # 已领礼包ID++
        $err = StoreProc::AddMultiItemInStore($req, $giftData->rewardstr);      # 发放奖励
        if ($err) {
            return Resp::err($err, '发放奖励失败');
        }
        $user->privateState = $privateState;
//        var_dump($privateState);
        $req->userInfo->game = $user;
        UserProc::updateUserInfo();                                         # 回写用户数据

        return Resp::ok(array(
                    'onlineGiftts' => $privateState->onlineGiftts,
                    'onlineGiftID' => $privateState->onlineGiftID,
                    'store' => $req->userInfo->game->store
        ));                                      # 设置返回值
    }

    /**
     * 清理/重置 在线礼包时间戳
     * @param Req $req
     */
    static private function ClearOnlineGiftTs($req) {
        $req->userInfo->game->privateState->onlineGiftts = 0;
        $req->userInfo->game->privateState->onlineGiftID = 1;
    }

// </editor-fold>
// <editor-fold defaultstate="collapsed" desc="    兑换码     ">

    /**
     * 凭兑换码领取礼包
     * @param Req $req
     */
    static function drawActivePackageByCode($req) {
        $user = new UserGameModel($req->userInfo->game);
        $privateState = new PrivateStateModel($user->privateState);
        $activeId = $req->paras[0];                                             # 取参数 活动id
        $active = GameConfig::activity_getItem($activeId);                      # 活动数据
        if (null == $active) {
            return Resp::err(ErrCode::active_const_no_err);
        }
        if ($active->startts > now() or $active->endts < now()) {               # 校验开放时间
            return Resp::err(ErrCode::active_time);
        }
        $codestring = $req->paras[1];                                           # 取参数 激活码
        if (!preg_match("/^[a-kmnp-z2-9]{10}$/", $codestring)) {                # 长度校验(10个字符)
            return Resp::err(ErrCode::active_activecode_format);
        }
        $activeCode = CipheredBase32::Decode($codestring);                      # 解码
        $codePlatStr = GameConstants::GetPlatStringByActivteCode($activeCode);  # platstr
        if (GameConstants::AllPlatStr !== $codePlatStr                          # 忽略全平台礼包
                && $req->userInfo->getPlatStr() !== $codePlatStr) {             # 平台字符串必须相符
            return Resp::err(ErrCode::active_activecode_plat, $codePlatStr); #   # 平台错误
        }
        if (!is_int($activeCode->number)                                        # 检查 兑换码的编号范围0~50000
                || $activeCode->number < 1 || $activeCode->number > 50000) {
            return Resp::err(ErrCode::active_activecode_format);
        }
        $packageID = $activeCode->package;                                      # 礼包id
        $packageInfo = GameConfig::tokenGift_getItem($packageID);               # 礼包常量数据
        if ($packageInfo == null) {                                             # 无效
            return Resp::err(ErrCode::err_const_no);
        }
        if ($packageInfo->expirets < now() || $packageInfo->startTs > now()) {  # 激活码已经失效,或者礼包尚未开启
            return Resp::err(ErrCode::active_activecode_outtime);
        }
        if (in_array($packageID, $privateState->usedTokens)) {                  # 已经领取过该礼包了
            return Resp::err(ErrCode::active_hasgetted);
        }
        if (self::checkActiveCodeIsUsed($activeCode)) {                         # 检查 该激活码是否已经使用过了
            return Resp::err(ErrCode::active_activecode_used);
        }                                                                       # 发放礼包,
        $err = StoreProc::AddMultiItemInStore($req, $packageInfo->reward);
        if ($err) {
            return Resp::err($err);
        }
        $req->userInfo->game->privateState->usedTokens[] = $packageID;          # 记录领取记录
        $ok = self::setActiveCodeUserRecord($activeCode, $req->uid);            # 插入数据库
        if (!$ok) {
            return Resp::err(ErrCode::err_db, daoInst()->getError(TRUE)); #     # 数据库操作失败- 重试
        }
        UserProc::updateUserInfo();                                         # 回存玩家数据
        $ret = array(#                                                          # 返回值
            "plat" => $codePlatStr,
            "packageId" => $activeCode->package,
            "reward" => $packageInfo->reward,
            'store' => $req->userInfo->game->store,
        );
        return Resp::ok($ret);                                                  # 返回成功信息
    }

    /**
     * 检查兑换码是否已经使用过了
     * @param ActiveCode $activeCode
     * @return boolean true : 已经用过了, false : 激活码尚未使用过.
     */
    static function checkActiveCodeIsUsed($activeCode) {
        $sql = sprintf("`plat`='%d' and `package`='%d' and `number`='%d'", #       # where 子句
                $activeCode->plat, $activeCode->package, $activeCode->number);
        $rows = daoInst()
                ->select()
                ->from(self::tab_toke_gift)                                     # 表名
                ->where($sql)
                ->count();
        return $rows > 0;
    }

    /**
     * 将兑换码添加到使用记录中
     * @param ActiveCode $actvieCode
     * @param string $uid
     * @return boolean true: 操作成功, false: 操作失败
     */
    static function setActiveCodeUserRecord($actvieCode, $uid) {
        $actvieCode->uid = $uid;                                                # 添加uid
        $ret = daoInst()
                ->insert(self::tab_toke_gift)                                   # 表名
                ->data($actvieCode)
                ->exec();
        return $ret > 0;
    }

// </editor-fold>

    /**
     * 每天重置
     * @param type $req
     */
    static function DailyReset($req) {
        self::DailyResetTaskAccountNum($req);
        self::ResetEverydayTask($req);
        self::ClearOnlineGiftTs($req);
        self::ClearDailyTiliGift($req);
    }

    /**
     * 清理每天的赠送体力领取记录
     * @param Req $req
     */
    private static function ClearDailyTiliGift($req) {
        $req->userInfo->game->privateState->dailyDrawedTiliGift = ArrayInit();
    }

    /**
     * 查询当前分区开放时间戳
     * @param Req $req
     */
    private static function GetZonePublicTS($req) {
        $zoneInfo = GameConfig::zonelist_getItem($req->zoneid);
        return Resp::ok($zoneInfo->publicTs);
    }

//
// <editor-fold defaultstate="collapsed" desc="     每日任务    ">
//

    /**
     * 普通任务 完成任务
     * @param Req $req
     */
    private static function Tasks_CompleteTask($req) {
        $taskId = $req->paras[0];                              // 任务ID
        $tasks = $req->userInfo->game->privateState->Tasks;
        if (!$tasks) {
            return Resp::err(ErrCode::user_data_broken_err);
        }
        if ($tasks->$taskId->state == 3) {
            return Resp::err(ErrCode::active_day7_taskstate_err);
        }
        $taskModel = GameConfig::task_getItem($taskId);
        if (!$taskModel) {
            return Resp::err(ErrCode::active_day7_const_no_err);
        }
        if (ActiveProc::CheckTaskComplete($taskModel, $req)) {  //下面该检测了,检测客户端发来的完成任务请求是否准确
            $tasks->$taskId->state = 2;                         // 更新任务状态
            UserProc::updateUserInfo();                     // 回写玩家数据
        }
        return Resp::ok(array("ret" => "ok"));
    }

    /**
     * 普通任务 - 领取奖励
     * @param Req $req
     */
    private static function Tasks_DrawReward($req) {
        $taskId = $req->paras[0];                                               // 任务ID
        $task = $req->userInfo->game->privateState->Tasks->$taskId;             // 取任务数据
        if (!$task) {                                                           // 找不到任务数据
            return Resp::err(ErrCode::active_day7_taskno_err);
        }
        if ($task->state == 1) {                                                // 看任务状态，如果是未完成状态，则报错
            return Resp::err(ErrCode::active_day7_taskstate_err);
        }
        if ($task->state != 2) {                                                // 看任务状态，如果是已领取状态，则直接返回当前数据
            $result = array(
                'store' => $req->userInfo->game->store,
                'heros' => $req->userInfo->game->heros,
                'cash' => $req->userInfo->game->cash,
                'tili' => $req->userInfo->game->tili,
                'time' => $req->userInfo->game->privateState->TiliTime,
                'gold' => $req->userInfo->game->gold
            );
            return Resp::ok($result);
        }
        $taskModel = GameConfig::task_getItem($taskId);                         // 取任务常量
        if (!$taskModel) {
            return Resp::err(ErrCode::active_day7_const_no_err);
        }

        $task->state = 3;                                                       // 修改任务状态
        $err = StoreProc::AddMultiItemInStore($req, $taskModel->reward, 2);

        if (ErrCode::ok != $err) {
            return Resp::err($err);
        }
        $result = array(
            'store' => $req->userInfo->game->store,
            'heros' => $req->userInfo->game->heros,
            'cash' => $req->userInfo->game->cash,
            'tili' => $req->userInfo->game->tili,
            'time' => $req->userInfo->game->privateState->TiliTime,
            'gold' => $req->userInfo->game->gold
        );
        return Resp::ok($result);
    }

    /**
     * 普通任务的完成
     * @param sm_task $taskModel 任务的数据
     * @param Req $req  
     */
    private static function CheckTaskComplete($taskModel, $req) {
////下面该检测了,检测客户端发来的完成任务请求是否准确
////数据库还没改好,不知道会用什么,暂时用老办法
        return true; ///////因为数据量太大，先这样测试
        switch ($taskModel->tasktype) {
            case 5://每日登录任务,只要能发送这个消息就说明他完成了登录任务,只需要判断当天是否已经领取过
// 建议改法: return $req->userInfo->game->privateState->LoginTaskComplete = 1;
                if ($req->userInfo->game->privateState->LoginTaskComplete == 0) {
                    $req->userInfo->game->privateState->LoginTaskComplete = 1;
                    return true;
                }
                break;
            case 11: // 战斗力是否达到要求,战斗力暂时不检测,
// 因为目前即使服务器验证也是客服端计算的上传结果.  20170311
                return true;
            case 12: //如果是英雄升级任务
                return $taskModel->canshu <= $req->userInfo->game->privateState->heroshengji;
            case 13://如果是英雄升阶任务
                return $taskModel->canshu <= $req->userInfo->game->privateState->heroshengjie;
            case 14: //如果是英雄技能升级任务
                return $taskModel->canshu <= $req->userInfo->game->privateState->herojinhua;
            case 15: //如果是英雄升星任务
                return $taskModel->canshu <= $req->userInfo->game->privateState->heroshengxing;
            case 21: //如果是通关任务普通
                return $taskModel->canshu <= $req->userInfo->game->gates->normal->highest;
            case 22://如果是通关任务困难
                return $taskModel->canshu <= $req->userInfo->game->gates->hard->highest;
            case 23://如果是通关任务精英
                return $taskModel->canshu <= $req->userInfo->game->gates->elite->highest;
            case 24://如果是通关任务次数
                return $taskModel->canshu <= $req->userInfo->game->gates->Times;
            case 25: # pvp 挑战次数
                return $taskModel->canshu <= $req->userInfo->game->pvp->dailyPkCnt;
            case 31: //如果是装备升级任务
                return $taskModel->canshu <= $req->userInfo->game->privateState->ItemUpgrage;
            case 32: //如果是宝石合成任务
                return $taskModel->canshu <= $req->userInfo->game->privateState->GemUpgrage;
//            case 41: //如果是好友任务
//                return $taskModel->canshu <= FriendProc::getCurrentFriendsCount($req);

            default :
                return false;
        }
    }

    /**
     * 更新任务计数
     * @param Req $req
     */
    public static function ChangeTaskCount($req) {
        switch ($req->cmd) {
            case CmdCode::cmd_hero_levelup:                                     # 英雄升级
                $req->userInfo->game->privateState->heroshengji++;
                break;
            case CmdCode::cmd_hero_strength:                                    # 英雄强化
                $req->userInfo->game->privateState->heroshengjie++;
                break;
            case CmdCode::cmd_hero_upstar:                                      # 英雄升星
                $req->userInfo->game->privateState->heroshengxing++;
                break;
            case CmdCode::cmd_hero_buyCollectHeroLimtCount:                     # 扩展英雄数量上限
                break;
            case CmdCode::cmd_hero_upgradeSkillLevel:                           # 升级技能
                $req->userInfo->game->privateState->herojinhua++;
                break;
            case CmdCode::cmd_store_ItemUpgrade:                                # 升级装备
                $req->userInfo->game->privateState->ItemUpgrage++;
                break;
            case CmdCode::cmd_store_GemCompose:                                 # 宝石合成
                $req->userInfo->game->privateState->GemUpgrage++;
                break;
        }
        UserProc::updateUserInfo();
    }

    public static function AddEverydayTask() {
        
    }

// </editor-fold>
//
    public static function RecoveryTili($req) {
        $useTili = $req->paras[0];
        ActiveProc::ChangeTili($useTili);

        UserProc::updateUserInfo();
        $result = array(
            'time' => $req->userInfo->game->privateState->TiliTime,
            'tili' => $req->userInfo->game->tili
        );
        $resp = Resp::ok($result);
        return $resp;
    }

    /**
     * 修改玩家体力
     * @param int $useTili $useTili>0代表增加体力,   $useTili<0代表消耗体力
     * @return type
     */
    public static function ChangeTili($useTili) {
        $req = req();
        $user = $req->userInfo->game;
        $moreTili = 0;                                                          # 超上限的体力值
// 如果没有tilitime这个值,说明是以前老用户新登录的,为了纠错在判断里面补值.(正常用户不会进入判断内部)
        if (!CommUtil::isPropertyExists($user->privateState, "TiliTime")) {
            $user->privateState->TiliTime = time() - 120;
        }
        if ($user->tili > 120) {                                                # 如果该账户体力值本身是大于上限的,获取一下超出的体力值
            $moreTili = $user->tili - 120;                                      # 用moreTili保存一下额外的体力值
        }
        $useTime = time() - $user->privateState->TiliTime;                      # 距离上次修改体力值的时间
        if ($useTime > 300) {                                                   # 该账户超过了单位体力时间,需要重新计算体力值
            if ($moreTili <= 0) {
                $user->tili += (int) ( (int) ($useTime / 300));
                if ($user->tili > 120) {                                        # 体力值上限
                    $user->tili = 120;
                } // 这代码真烂,以后用的时候再修复吧... -gwang 20200110154858
            }
            $user->privateState->TiliTime = time();
        }
        if ($useTili < 0) {                                                     # 如果是消耗体力
            my_Assert(abs($useTili) < $user->tili, ErrCode::notenough_tili);    # 体力不足
            $user->tili += $useTili;                                            # 扣除体力
        } else if ($useTili > 0) {                                              # 如果是购买增加体力
            $user->tili += $useTili;
        }
        return ErrCode::ok;
    }

    /**
     * 重置每日任务相关计数器
     * @param Req $req
     */
    static function DailyResetTaskAccountNum($req) {
        $req->userInfo->game->gates->Times = 0;
        $req->userInfo->game->privateState->GemUpgrage = 0;
        $req->userInfo->game->privateState->ItemUpgrage = 0;
        $req->userInfo->game->privateState->herojinhua = 0;
        $req->userInfo->game->privateState->heroshengji = 0;
        $req->userInfo->game->privateState->heroshengjie = 0;
        $req->userInfo->game->privateState->heroshengxing = 0;
        $req->userInfo->game->privateState->LoginTaskComplete = 0;
        if (count($req->userInfo->game->privateState->LoginDays) < 7) {
            $req->userInfo->game->privateState->LoginDays[] = tsDay();
        }
    }

    /**
     * 清理每日任务,每天都会将每日任务置为未完成状态
     * @param type $req
     */
    public static function ResetEverydayTask($req) {
        $tasks = $req->userInfo->game->privateState->Tasks;
        $conTasks = GameConfig::task();
        $arrTask = ArrayInit();
        //    var_dump($conTasks);
        foreach ($conTasks as $s_taskid => $s_task) {

            if ($s_task->ban == 1) {                                            # 每日任务
                if (CommUtil::isPropertyExists($tasks, $s_taskid)) {
                    unset($tasks->$s_taskid);
                }
                $val = explode(",", $s_task->taskrank);
                $lowlevel = $val[0];
                $highlevel = $val[1];
                if ($req->userInfo->game->level > $lowlevel && $req->userInfo->game->level <= $highlevel) {
                    $tasks->$s_taskid = json_decode('{"state":1}');
                    //   $arrTask[] = $s_taskid;
                    // var_dump($arrTask);
                }
            } else {
                if ($s_task->ban == 5) {                                        # pvp任务
                    $tasks->$s_taskid = json_decode('{"state":1}');
                }
            }
        }
        // $rand_keys = array_rand($arrTask, 5);                                   # 每日任务随机出现5个
//        foreach ($rand_keys as $index) {
//            $s_taskid = $arrTask[$index];
//            $tasks->$s_taskid->state = 1;
//        }
// $req->userInfo->game->privateState->LoginCount = 1;
        $req->userInfo->game->privateState->Tasks = $tasks;
    }

}