package com.linghu.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.linghu.model.common.ResponseResult;
import com.linghu.model.entity.Question;
import com.linghu.service.QuestionService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import com.linghu.model.dto.KeywordDto;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/question")
@Api(value = "提问词相关接口", tags = "订单管理-提问词")
public class QuestionController {

    @Autowired
    private QuestionService questionService;

    @PostMapping
    @ApiOperation(value = "添加提问词")
    @Transactional
    public ResponseResult<List<Question>> add(@RequestBody KeywordDto keywordDto) {

        List<Question> questionList = Arrays.stream(keywordDto.getQuestions().split("\\n"))
                .filter(q -> !q.trim().isEmpty())
                .map(q -> {
                    Question question = new Question();
                    question.setKeyword_id(keywordDto.getKeyword_id());
                    question.setQuestion(q.trim());
                    question.setStatus("pending");

                    return question;
                }).collect(Collectors.toList());

        boolean success = questionService.saveBatch(questionList);
        if (success) {
            return ResponseResult.success(questionList);
        }
        return ResponseResult.error("添加提问词失败");
    }

    // @DeleteMapping("/{questionId}")
    // public ResponseResult<Void> delete(@PathVariable Integer questionId) {
    // Question question = new Question();
    // question.setQuestion_id(questionId);
    // question.setDel_flag(1);
    // boolean success = questionService.updateById(question);
    // if (success) {
    // return ResponseResult.success();
    // }
    // return ResponseResult.error("删除提问词失败");
    // }

    @PutMapping
    @Transactional
    public ResponseResult<Void> update(@RequestBody List<Question> questions) {
        boolean success = questionService.updateBatchById(questions);
        // 不存在的问题id就新增
        List<Question> newQuestions = questions.stream()
                .filter(q -> q.getQuestion_id() == null)
                .collect(Collectors.toList());
        if (!newQuestions.isEmpty()) {
            questionService.saveBatch(newQuestions);
        }
        if (success) {
            return ResponseResult.success();
        }
        return ResponseResult.error("更新提问词失败");
    }

    @GetMapping("/{questionId}")
    public ResponseResult<Question> getById(@PathVariable Integer questionId) {
        Question question = questionService.getById(questionId);
        if (question != null) {
            return ResponseResult.success(question);
        }
        return ResponseResult.error("提问词不存在");
    }

    // @DeleteMapping("/batch")
    // @Transactional
    // public ResponseResult<Void> batchDelete(@RequestBody List<Integer>
    // questionIds) {
    // List<Question> questions = questionIds.stream().map(id -> {
    // Question question = new Question();
    // question.setQuestion_id(id);
    // return question;
    // }).collect(Collectors.toList());

    // boolean success = questionService.updateBatchById(questions);
    // if (success) {
    // return ResponseResult.success();
    // }
    // return ResponseResult.error("批量删除提问词失败");
    // }

    @GetMapping("/list")
    public ResponseResult<List<Question>> list() {
        LambdaQueryWrapper<Question> queryWrapper = new LambdaQueryWrapper<>();
        List<Question> list = questionService.list(queryWrapper);
        return ResponseResult.success(list);

    }
}