<?php

namespace App\Http\Controllers\Admin\Exam;

use App\Http\Controllers\Controller;
use App\Repositories\Enums\Exam\TypeEnum;
use App\Repositories\Enums\ModelStatusEnum;
use App\Repositories\Enums\PermissionEnum;
use App\Repositories\Enums\ResponseCodeEnum;
use App\Repositories\Models\Base\Admin;
use App\Repositories\Models\Dianli\Task;
use App\Repositories\Models\Exam\Paper;
use App\Repositories\Models\Exam\PaperResult;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Jiannei\Response\Laravel\Support\Facades\Response;
use Prettus\Validator\Contracts\ValidatorInterface;
use App\Contracts\Repositories\Exam\PaperResultRepository;
use App\Repositories\Validators\Exam\PaperResultValidator;

/**
 * Class PaperResultsController.
 *
 * @package namespace App\Http\Controllers\Exam;
 */
class PaperResultsController extends Controller
{
    /**
     * @var PaperResultRepository
     */
    protected $repository;

    /**
     * @var PaperResultValidator
     */
    protected $validator;

    /**
     * PaperResultsController constructor.
     *
     * @param PaperResultRepository $repository
     * @param PaperResultValidator $validator
     */
    public function __construct(PaperResultRepository $repository, PaperResultValidator $validator)
    {
        $this->repository = $repository;
        $this->validator = $validator;
    }

    /**
     * 列表
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function index(Request $request)
    {
        $this->isCan(PermissionEnum::controller_paperResult_list);
        $lists = $this->repository->paginate($request->get('per_page', self::PAGE_NUM));
        return Response::success($lists);
    }

    /**
     * 添加
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource|void
     * @throws \Illuminate\Validation\ValidationException
     * Author: Mead
     */
    public function store(Request $request)
    {
        $this->validate($request, $this->validator->getRules(ValidatorInterface::RULE_CREATE));
        $data = $request->only(array_keys($this->validator->getRules(ValidatorInterface::RULE_CREATE)));

        $type = $request->get('type');
        if (in_array($type, [1, 2, 5])) {
            $this->validate($request, [
                'body' => 'required'
            ]);
        }

        try {
            $data['admin_id'] = login_admin_id();
            $model = $this->repository->create($data);
            return Response::success($model);
        } catch (\Exception $e) {
            return $this->error($e);
        }
    }

    /**
     * 详情
     * @param $id
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function show($id)
    {
        $data = $this->repository->find($id);
        return Response::success($data);
    }

    /**
     * 更新
     * @param Request $request
     * @param $id
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * @throws \Illuminate\Validation\ValidationException
     * Author: Mead
     */
    public function update(Request $request, $id)
    {
        $this->validate($request, $this->validator->getRules(ValidatorInterface::RULE_UPDATE));
        $data = $request->only(array_keys($this->validator->getRules(ValidatorInterface::RULE_CREATE)));
        $type = $request->get('type');
        if (in_array($type, [1, 2, 5])) {
            $this->validate($request, [
                'body' => 'required'
            ]);
        }

        try {

            $model = $this->repository->update($data, $id);
            return Response::success($model);
        } catch (\Exception $e) {
            $this->error($e);
        }
    }

    /**
     * 删除
     * @param $id
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function destroy($id)
    {
        try {
            $this->repository->skipPresenter()->delete($id);
            return Response::success(null, T('successfully delete.'));
        } catch (\Exception $exception) {
            return Response::fail(T('Delete failed.'), ResponseCodeEnum::SERVICE_UPDATE_DATA_ERROR);
        }
    }

    /**
     * 批量删除
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function delete(Request $request)
    {
        try {
            $this->validate($request, [
                'ids' => 'required|array',
            ]);

            $ids = $request->get('ids');
            $this->repository->whereIn('id', $ids)->delete();
            return Response::success(null, T('successfully delete.'));
        } catch (\Exception $exception) {
            return Response::fail(T('Delete failed.'), ResponseCodeEnum::SERVICE_UPDATE_DATA_ERROR);
        }
    }

    /**
     * 选项
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * Author: Mead
     */
    public function selectOptions(Request $request)
    {
        $data = $this->repository->skipPresenter()->all(['name', 'id']);
        return Response::success($data);
    }

    /**
     * 暂停
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * @throws \Illuminate\Validation\ValidationException
     */
    public function pause(Request $request)
    {
        $this->validate($request, [
            'id' => 'required|integer',
            'type' => 'sometimes|nullable|integer',
        ]);
        $status = ModelStatusEnum::PAUSE;
        if ($request->get('type')) {
            $status = ModelStatusEnum::OK;
        }

        $re = PaperResult::query()->where('id', $request->get('id'))->update(['status' => $status]);
        if ($re) {
            return Response::success([]);
        }
        return $this->error('操作失败');
    }

    /**
     * 分配任务
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * @throws \Illuminate\Validation\ValidationException
     */
    public function allot(Request $request)
    {
        $this->validate($request, [
            'task_id' => 'required|integer',
            'admin_ids' => 'required|array',
            'day' => 'required|date',
            'assign_admin_id' => 'sometimes|integer',
        ]);

        $this->isCanAny([PermissionEnum::controller_task_allot, PermissionEnum::controller_task_allot_all]);

        if ($this->isCan(PermissionEnum::controller_task_allot_all, true)) {
            $this->validate($request, [
                'assign_admin_id' => 'required|integer',
            ]);
        }
        $task_id = $request->get('task_id');
        $day = $request->get('day');
        $admin_ids = $request->get('admin_ids', []);
        $admin_id = login_admin_id();
        $assign_admin_id = $request->get('assign_admin_id', $admin_id);

        $task = false;
        if ($this->isCan(PermissionEnum::controller_task_allot_all, true)) {
            $task = Task::query()->where('id', $task_id)->where('status', ModelStatusEnum::OK)->first();
        } else {
            $task = Task::query()->where('id', $task_id)->where('assign_admin_ids', 'like', "%-{$assign_admin_id}-%")->where('status', ModelStatusEnum::OK)->first();
        }

        if (!$task) {
            return $this->error('找不到该任务');
        }

        $admins = Admin::query()->whereIn('id', $admin_ids)->where('status', ModelStatusEnum::OK)->count();
        if ($admins !== count($admin_ids)) {
            return $this->error('巡检员数量不对');
        }

        foreach ($admin_ids as $admin) {
            PaperResult::query()->create([
                'day' => $day,
                'paper_id' => $task->paper_id,
                'assign_admin_id' => $assign_admin_id,
                'polling_admin_id' => $admin,
                'admin_id' => $admin_id,
                'is_answer' => 0,
                'status' => 1,
            ]);
        }

        return Response::success([]);
    }

    /**
     * 答题
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse|\Illuminate\Http\Resources\Json\Resource
     * @throws \Illuminate\Validation\ValidationException
     */
    public function answer(Request $request)
    {
        $this->isCan(PermissionEnum::controller_paperResult_answer);

        $this->validate($request, [
            'id' => 'required|integer',
            'results' => 'required|array',
            'is_exist_danger' => 'required|in:0,1',
            'remark' => 'sometimes|nullable',
            'imgs' => 'sometimes|nullable|array',
        ]);

        $id = $request->get('id');
        $is_exist_danger = $request->get('is_exist_danger', 0);
        $remark = $request->get('remark');
        $results = $request->get('results', []);
        $imgs = $request->get('imgs', []);
//        ->where('polling_admin_id', login_admin_id())
        $model = PaperResult::query()->where('id', $id)->first();
        if (!$model) {
            return $this->error('找不到该任务');
        }
        if ($model->is_answer) {
            return $this->error('该任务您已经完成');
        }
        $paper = Paper::query()->find($model->paper_id);
        $topics = $paper->topics;

        if (count($topics) !== count($results)) {
            return $this->error('试题与答案不匹配！');
        }

        //验证是否合法
        foreach ($topics as $key => $topic) {
            $k = $key + 1;
            if (!isset($results[$key])) {
                return $this->error("第{$k}条题：答案找不到");
            }
            $result = $results[$key];

            switch ($topic->type) {
                case TypeEnum::XUANZE:
                case TypeEnum::PANDUAN:
                    //单选
                    if (!in_array($result, array_column($topic->body, 'key'))) {
                        return $this->error("第{$k}条题：答案不合法");
                    }
                    break;
                case TypeEnum::TIANKONG:
                case TypeEnum::JIANDA:
                    if (!is_string($result)) {
                        return $this->error("第{$k}条题：答案不合法");
                    }
                    break;
                case TypeEnum::DUOXUAN:
                    if (!is_array($result)) {
                        return $this->error("第{$k}条题：答案不合法");
                    }
                    $kk = array_column($topic->body, 'key');
                    foreach ($result as $r) {
                        if (!in_array($r, $kk)) {
                            return $this->error("第{$k}条题：答案不合法");
                        }
                    }
                    break;
            }
        }

        //计算分
        $mark = 0;
        $is_examines = 0;
        $n_results = [];
        foreach ($topics as $key => $topic) {
            $result = $results[$key];

            $n_results[$key]['value'] = $result;
            $n_results[$key]['mark'] = 0;
            $n_results[$key]['point'] = $topic->point;
            $n_results[$key]['is_examines'] = 0;
            $f = false;
            switch ($topic->type) {
                case TypeEnum::XUANZE:
                    //单选
                    $n_results[$key]['is_examines'] = 1;
                    if ($result == $topic->result) {
                        $mark += $topic->point;
                        $n_results[$key]['mark'] = $topic->point;
                    }
                    break;
                case TypeEnum::PANDUAN:
                    $n_results[$key]['is_examines'] = 1;
                    if ($result == $topic->result) {
                        $mark += $topic->point;
                        $n_results[$key]['mark'] = $topic->point;
                    }
                    break;
                case TypeEnum::TIANKONG:
                    $n_results[$key]['is_examines'] = 0;
                    if ($result == $topic->result) {
                        $mark += $topic->point;
                        $n_results[$key]['mark'] = $topic->point;
                    }
                    $is_examines = 0;
                    $f = true;
                    break;
                case TypeEnum::JIANDA:
                    $is_examines = 0;
                    $f = true;
                    break;
                case TypeEnum::DUOXUAN:
                    $n_results[$key]['is_examines'] = 1;
                    if (count($result) <= count($topic->result)) {
                        if (count(array_intersect($result, $topic->result)) == count($topic->result)) {
                            $mark += $topic->point;
                            $n_results[$key]['mark'] = $topic->point;
                        } else {
                            if (!count(array_diff($result, $topic->result))) {
                                $p = ceil($topic->point / 2);
                                $mark += $p;
                                $n_results[$key]['mark'] = $p;
                            }
                        }
                    }
                    break;
            }
        }

        if ($f) {
            $is_examines = 0;
        }

        $model->result = $n_results;
        $model->obiective_mark = $mark;
        $model->subjective_mark = 0;
        $model->mark = $mark;
        $model->is_examines = $is_examines;
        $model->total_mak = $paper->mark;
        $model->is_exist_danger = $is_exist_danger;
        $model->is_answer = 1;
        $model->remark = $remark;
        $model->imgs = $imgs;
        $model->answer_at = Carbon::now();
        $model->save();
        $paper->submit_nums += $paper->submit_nums;
        $paper->save();
        return Response::success([]);
    }
}