<?php

namespace app\admin\controller\app\exam;

use app\common\controller\Backend;
use PDOException;
use think\Db;
use think\Exception;
use think\exception\ValidateException;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Cell\DataType;
/**
 * 题库
 *
 * @icon fa fa-circle-o
 */
class WarehouseQuestion extends Backend
{

    /**
     * WarehouseQuestion模型对象
     * @var \app\admin\model\app\exam\WarehouseQuestion
     */
    protected $model = null;

    /**
     * WarehouseGroup模型对象
     * @var \app\admin\model\app\exam\WarehouseGroup
     */
    protected $warehouseGroupModel = null;

    public function _initialize()
    {
        parent::_initialize();
        $this->model = new \app\admin\model\app\exam\WarehouseQuestion;
        $this->warehouseGroupModel = new \app\admin\model\app\exam\WarehouseGroup;
    }

    /**
     * 校验题目数据
     * @param string $type 题型
     * @param array $option 选项
     * @param mixed $answer 答案
     */
    protected function validateQuestionData($type, $option, $answer)
    {
        switch ($type) {
            case 'fillblank':
                if (empty($answer) || !is_array($answer)) {
                    $this->error('填空题答案为空，请填写至少一个填空答案');
                }
                $hasValidBlank = false;
                foreach ($answer as $blankAnswers) {
                    if (is_array($blankAnswers) && !empty($blankAnswers)) {
                        $hasValidBlank = true;
                        break;
                    }
                }
                if (!$hasValidBlank) {
                    $this->error('填空题答案为空，请填写至少一个填空答案');
                }
                break;
            case 'indefinite':
                if (empty($option) || !is_array($option) || count($option) < 2) {
                    $this->error('不定项选择题选项不足，请添加至少 2 个选项');
                }
                if (empty($answer) || !is_array($answer)) {
                    $this->error('不定项选择题答案为空，请选择正确答案');
                }
                break;
            case 'essay':
                if (empty($answer) || !is_string($answer)) {
                    $this->error('问答题参考答案为空，请填写参考答案');
                }
                break;
        }
    }

    /**
     * 将请求中的答案统一转换为便于校验的结构
     * @param string $type 题型
     * @param mixed $answer 请求中的答案
     * @return mixed
     */
    protected function normalizeAnswerFromRequest($type, $answer)
    {
        if (in_array($type, ['multiple', 'indefinite', 'fillblank'])) {
            return is_array($answer) ? $answer : [];
        }
        return $answer;
    }

    /**
     * 将选项格式化为数据库存储格式
     * @param string $type 题型
     * @param mixed $option 选项
     * @return string
     */
    protected function formatOptionForStorage($type, $option)
    {
        return json_encode(is_array($option) ? $option : []);
    }

    /**
     * 将答案格式化为数据库存储格式
     * @param string $type 题型
     * @param mixed $answer 答案
     * @return string
     */
    protected function formatAnswerForStorage($type, $answer)
    {
        switch ($type) {
            case 'multiple':
            case 'indefinite':
                return is_array($answer) ? implode(',', $answer) : (string)$answer;
            case 'fillblank':
                return is_array($answer) ? json_encode($answer) : (string)$answer;
            case 'essay':
                return (string)$answer;
            case 'single':
            case 'judge':
            default:
                return (string)$answer;
        }
    }

    /**
     * 将数据库中的答案格式化为接口返回格式
     * @param string $type 题型
     * @param mixed $answer 数据库中的答案
     * @return mixed
     */
    protected function formatAnswerForDetail($type, $answer)
    {
        switch ($type) {
            case 'multiple':
            case 'indefinite':
                $answer = explode(',', $answer);
                foreach ($answer as $index => $option) {
                    $answer[$index] = intval($option);
                }
                return $answer;
            case 'fillblank':
                $answer = json_decode($answer, true);
                return is_array($answer) ? $answer : [];
            case 'essay':
                return $answer;
            case 'single':
            case 'judge':
            default:
                return intval($answer);
        }
    }


    /**
     * 列表
    */
    public function index()
    {
       //当前是否为关联查询
       $this->relationSearch = true;
       //设置过滤方法
       $this->request->filter(['strip_tags', 'trim']);
       //如果发送的来源是Selectpage，则转发到Selectpage
       if ($this->request->request('keyField')) {
           return $this->selectpage();
       }
       list($where, $sort, $order, $offset, $limit, $page, $alias, $bind,$originWhere) = $this->buildparams();


       $list = $this->model
          ->with(['group'])
          ->where($where)
          ->order($sort, $order)
          ->paginate($limit);

       foreach ($list as $row) {
           $row->visible(['id','question','type','degree','option','createtime','group']);
           $row->question = strip_tags($row->question);
       }

       
       $result = array("total" => $list->total(), "rows" => $list->items(),'attr'=>[
           'typeList' => $this->model->getTypeList(),
           'degreeList' => $this->model->getDegreeList()
       ]);
       
       return $this->success("获取成功",$result);
    }

    /**
     * 导出题库
     * @return void
     */
    public function export()
    {
        $ids = input('ids/a', []);
        $this->request->filter(['strip_tags', 'trim']);
        list($where, $sort, $order, $offset, $limit, $page, $alias, $bind, $originWhere) = $this->buildparams();

        $query = $this->model->where('uniacid', UNIACID);
        if (!empty($ids)) {
            $query->where('id', 'in', $ids);
        }
        $query->where($where);

        $questions = $query->order('id', 'asc')->select();
        if (empty($questions)) {
            $this->error('没有可导出的题目');
        }

        $spreadsheet = $this->buildExportSpreadsheet($questions);
        $filename = '题库导出_' . date('Y-m-d_H-i') . '.xlsx';

        if (ob_get_level() > 0) {
            ob_clean();
        }
        header('Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
        header('Content-Disposition: attachment;filename="' . $filename . '"');
        header('Cache-Control: max-age=0');

        $writer = IOFactory::createWriter($spreadsheet, 'Xlsx');
        $writer->save('php://output');
    }

    /**
     * 构建导出用 Spreadsheet
     * @param mixed $questions
     * @return Spreadsheet
     */
    protected function buildExportSpreadsheet($questions)
    {
        $typeList = $this->model->getTypeList();
        $typeOrder = ['single', 'multiple', 'judge', 'indefinite', 'fillblank', 'essay'];
        $headers = [
            'single'     => ['题目', '选项A', '选项B', '选项C', '选项D', '选项E', '选项F', '选项G', '选项H', '选项I', '选项J', '正确答案', '解析'],
            'multiple'   => ['题目', '选项A', '选项B', '选项C', '选项D', '选项E', '选项F', '选项G', '选项H', '选项I', '选项J', '正确答案', '解析'],
            'indefinite' => ['题目', '选项A', '选项B', '选项C', '选项D', '选项E', '选项F', '选项G', '选项H', '选项I', '选项J', '正确答案', '解析'],
            'judge'      => ['题目', '正确/错误', '解析'],
            'fillblank'  => ['题目', '答案（空格用|分隔，备选用,分隔）', '解析'],
            'essay'      => ['题目', '参考答案', '解析'],
        ];

        $spreadsheet = new Spreadsheet();
        $sheetIndex = 0;
        $typeSheets = [];

        foreach ($typeOrder as $type) {
            if ($sheetIndex === 0) {
                $sheet = $spreadsheet->getActiveSheet();
            } else {
                $sheet = new \PhpOffice\PhpSpreadsheet\Worksheet\Worksheet($spreadsheet, $typeList[$type] ?? $type);
                $spreadsheet->addSheet($sheet);
            }
            $sheet->setTitle($typeList[$type] ?? $type);

            foreach ($headers[$type] as $colIndex => $title) {
                $sheet->setCellValueExplicitByColumnAndRow($colIndex + 1, 1, $title, DataType::TYPE_STRING);
            }

            $typeSheets[$type] = ['sheet' => $sheet, 'row' => 2];
            $sheetIndex++;
        }

        foreach ($questions as $question) {
            $type = $question['type'];
            if (!isset($typeSheets[$type])) {
                continue;
            }

            $rowData = $this->buildExportRow($question);
            foreach ($rowData as $colIndex => $value) {
                $typeSheets[$type]['sheet']->setCellValueExplicitByColumnAndRow($colIndex + 1, $typeSheets[$type]['row'], $value, DataType::TYPE_STRING);
            }
            $typeSheets[$type]['row']++;
        }

        $spreadsheet->setActiveSheetIndex(0);
        return $spreadsheet;
    }

    /**
     * 构建单行导出数据
     * @param mixed $question
     * @return array
     */
    protected function buildExportRow($question)
    {
        $type = $question['type'];
        $questionText = $this->plainText($question['question']);
        $analysis = $this->plainText($question['analysis']);

        switch ($type) {
            case 'single':
            case 'multiple':
            case 'indefinite':
                $option = is_array($question['option']) ? $question['option'] : json_decode($question['option'], true);
                if (!is_array($option)) {
                    $option = [];
                }
                $row = [$questionText];
                for ($i = 0; $i < 10; $i++) {
                    $row[] = isset($option[$i]) ? $this->plainText($option[$i]) : '';
                }
                $row[] = $this->answerToLetters($type, $question['answer']);
                $row[] = $analysis;
                return $row;

            case 'judge':
                $answer = (string)$question['answer'] === '0' ? '正确' : '错误';
                return [$questionText, $answer, $analysis];

            case 'fillblank':
                $answer = json_decode($question['answer'], true);
                if (!is_array($answer)) {
                    $answer = [];
                }
                $parts = [];
                foreach ($answer as $blank) {
                    $parts[] = is_array($blank) ? implode(',', $blank) : (string)$blank;
                }
                return [$questionText, implode('|', $parts), $analysis];

            case 'essay':
                return [$questionText, $this->plainText($question['answer']), $analysis];

            default:
                return [$questionText];
        }
    }

    /**
     * 将答案索引转换为字母
     * @param string $type
     * @param mixed $answer
     * @return string
     */
    protected function answerToLetters($type, $answer)
    {
        if (in_array($type, ['multiple', 'indefinite'])) {
            $indices = explode(',', (string)$answer);
        } else {
            $indices = [(int)$answer];
        }

        $letters = '';
        foreach ($indices as $index) {
            $index = (int)$index;
            if ($index >= 0 && $index < 26) {
                $letters .= chr(65 + $index);
            }
        }
        return $letters;
    }

    /**
     * 富文本转纯文本
     * @param mixed $content
     * @return string
     */
    protected function plainText($content)
    {
        if (is_null($content)) {
            return '';
        }
        return html_entity_decode(strip_tags((string)$content), ENT_QUOTES | ENT_HTML5, 'UTF-8');
    }

    /**
     * 添加
     *
     * @return string
     * @throws \think\Exception
     */
    public function add()
    {
        if (false === $this->request->isPost()) {
            return $this->view->fetch();
        }
        $params = $this->request->post('row/a');
        if (empty($params)) {
            $this->error(__('Parameter %s can not be empty', ''));
        }
        $params = $this->preExcludeFields($params);

        if ($this->dataLimit && $this->dataLimitFieldAutoFill) {
            $params[$this->dataLimitField] = $this->auth->id;
        }

        $params['uniacid'] = UNIACID;

        $params['option'] = is_array($params['option']) ? $params['option'] : [];
        $params['answer'] = $this->normalizeAnswerFromRequest($params['type'], $params['answer']);
        $this->validateQuestionData($params['type'], $params['option'], $params['answer']);
        $params['option'] = $this->formatOptionForStorage($params['type'], $params['option']);
        $params['answer'] = $this->formatAnswerForStorage($params['type'], $params['answer']);

        $result = false;
        Db::startTrans();
        try {
            //是否采用模型验证
            if ($this->modelValidate) {
                $name = str_replace("\\model\\", "\\validate\\", get_class($this->model));
                $validate = is_bool($this->modelValidate) ? ($this->modelSceneValidate ? $name . '.add' : $name) : $this->modelValidate;
                $this->model->validateFailException()->validate($validate);
            }
            $result = $this->model->allowField(true)->save($params);
            Db::commit();
        } catch (ValidateException|PDOException|Exception $e) {
            Db::rollback();
            $this->error($e->getMessage());
        }
        if ($result === false) {
            $this->error(__('No rows were inserted'));
        }
        $this->success("提交成功");
    }

    /**
     * 编辑
     *
     * @param $ids
     * @return string
     * @throws DbException
     * @throws \think\Exception
     */
    public function edit($ids = null)
    {
        $row = $this->model->get($ids);
        if (!$row) {
            $this->error(__('No Results were found'));
        }
        $adminIds = $this->getDataLimitAdminIds();
        if (is_array($adminIds) && !in_array($row[$this->dataLimitField], $adminIds)) {
            $this->error(__('You have no permission'));
        }

        $params = $this->request->post('row/a');
        if (empty($params)) {
            $this->error(__('Parameter %s can not be empty', ''));
        }
        $params = $this->preExcludeFields($params);

        $params['option'] = is_array($params['option']) ? $params['option'] : [];
        $params['answer'] = $this->normalizeAnswerFromRequest($params['type'], $params['answer']);
        $this->validateQuestionData($params['type'], $params['option'], $params['answer']);
        $params['option'] = $this->formatOptionForStorage($params['type'], $params['option']);
        $params['answer'] = $this->formatAnswerForStorage($params['type'], $params['answer']);
        $params['createtime'] = time();

        $result = false;
        Db::startTrans();
        try {
            //是否采用模型验证
            if ($this->modelValidate) {
                $name = str_replace("\\model\\", "\\validate\\", get_class($this->model));
                $validate = is_bool($this->modelValidate) ? ($this->modelSceneValidate ? $name . '.edit' : $name) : $this->modelValidate;
                $row->validateFailException()->validate($validate);
            }
            $result = $row->allowField(true)->save($params);
            Db::commit();
        } catch (ValidateException|PDOException|Exception $e) {
            Db::rollback();
            $this->error($e->getMessage());
        }
        if (false === $result) {
            $this->error(__('No rows were updated'));
        }
        $this->success("提交成功");
    }

    /**
     * 获取详情
     * @param $id
     * @return mixed
     */
    public function detail($id){
        $row = $this->model->get($id);
        if (!$row) {
            $this->error(__('No Results were found'));
        }

        $row['answer'] = $this->formatAnswerForDetail($row['type'], $row['answer']);

        return $this->success("获取成功",$row);
    }

    /**
     * 复制题目
     * @return void
     */
    public function copy($ids=null){
        if (false === $this->request->isPost()) {
            $this->error(__("Invalid parameters"));
        }
        $ids = $ids ?: $this->request->post("ids");
        if (empty($ids)) {
            $this->error(__('Parameter %s can not be empty', 'ids'));
        }

        $pk = $this->model->getPk();
        $adminIds = $this->getDataLimitAdminIds();
        if (is_array($adminIds)) {
            $this->model->where($this->dataLimitField, 'in', $adminIds);
        }
        $list = $this->model->where($pk, 'in', $ids)->select();

        $count = 0;
        Db::startTrans();
        try {
            foreach ($list as $item) {
                $item = $item->toArray();
                unset($item['id']);
                $item['createtime'] = time();
                $item['option'] = $this->formatOptionForStorage($item['type'], $item['option']);
                $item['answer'] = $this->formatAnswerForStorage($item['type'], $item['answer']);
                $this->model->insert($item);
                $count++;
            }
            Db::commit();
        } catch (PDOException|Exception $e) {
            Db::rollback();
            $this->error($e->getMessage());
        }
        if ($count) {
            $this->success("操作成功");
        }
        $this->error(__('未操作任何数据'));
    }

    /**
     * 转移分组
     * @return void
     */
    public function move($ids=null,$groupId = 0){
        if (false === $this->request->isPost()) {
            $this->error(__("Invalid parameters"));
        }
        $ids = $ids ?: $this->request->post("ids");
        if (empty($ids)) {
            $this->error(__('Parameter %s can not be empty', 'ids'));
        }

        $groupId = $groupId ?: $this->request->post("group_id");

        $pk = $this->model->getPk();
        $adminIds = $this->getDataLimitAdminIds();
        if (is_array($adminIds)) {
            $this->model->where($this->dataLimitField, 'in', $adminIds);
        }
        $list = $this->model->where($pk, 'in', $ids)->select();

        $count = 0;
        Db::startTrans();
        try {
            foreach ($list as $item) {
                $row = [
                    'group_id'=>$groupId
                ];

                $this->model->where([
                    'id'=>$item['id']
                ])->update($row);
                $count++;
            }
            Db::commit();
        } catch (PDOException|Exception $e) {
            Db::rollback();
            $this->error($e->getMessage());
        }
        if ($count) {
            $this->success("操作成功");
        }
        $this->error(__('未操作任何数据'));
    }

    /**
     * 获取题目数量
     * @remark 通过分组 ids 数组获取题目不同类型对应的数量
     * @return void
     */
    /**
     * 获取题目数量
     * @remark 通过分组 ids 数组获取题目不同类型对应的数量
     * @return void
     */
    public function groupGetQuestionTypeTotal(){
        $groupIds = input('ids/a');
        
        if(!$groupIds){
            $groupIds = input('group_ids/a');
        }
        $list = $this->model->where([
            'group_id'=>['in',$groupIds]
        ])->field([
            'type','COUNT(*) as count'
        ])->group('type')->select();
        $this->success("获取成功",$list);
    }

    /**
     * 随机返回题目
     * @remark 通过分组 ids 和 不同类型指定的数量随机返回题目
     * @return void
     */
    public function getTypeRandomQuestion(){
        $groupIds = input('group_ids/a');
        $type_num = input('type_num/a');

        $questions = [];

        foreach ($type_num as $type => $num){
            if($num==0){
                continue;
            }
            $temp = $this->model->where([
                'group_id'=>['in',$groupIds],
                'type'=>$type,
            ])->limit($num)->orderRaw('RAND()')->select();
            $questions = array_merge($questions,$temp);
        }

        $this->success("获取成功",$questions);
    }
}