package cn.seecoder.bok.client;

import cn.seecoder.bok.common.QuestionType;
import cn.seecoder.bok.common.api.*;
import cn.seecoder.bok.common.dto.CollectDTO;
import cn.seecoder.bok.common.dto.RateDTO;
import cn.seecoder.bok.common.utility.RestPage;
import cn.seecoder.bok.common.vo.*;
import com.fasterxml.jackson.core.type.TypeReference;
import okhttp3.HttpUrl;
import okhttp3.Response;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import static cn.seecoder.bok.client.ParamUtil.*;

/**
 * @author kunduin
 */
public class SeecoderBokClient
        implements SeecoderBokQuestionApi, SeecoderBokQuestionQueryApi,
        SeecoderBokRecordApi, SeecoderBokUserInteractiveApi,
        SeecoderBokKnowledgeApi {

    private final OkRequest req;

    /**
     * 创建client
     *
     * @param host bok地址，示例：{@code "http://bok.seecoder.cn"}
     */
    public SeecoderBokClient(String host) {
        req = new OkRequest(host);
    }

    @Override
    @Deprecated
    public List<KnowledgeNodeVO> getKnowledgeNode(String name) {
        HttpUrl httpUrl = req.createUrlBuilder("/api/knowledge")
                .addQueryParameter("name", name).build();
        Response response = req.get(httpUrl);
        return req.getResponseBody(response, new TypeReference<List<KnowledgeNodeVO>>() {})
                .orElse(Collections.emptyList());
    }

    @Override
    public Page<QuestionVO> getQuestionList(String stem, List<String> tags,
                                            List<QuestionType> types, List<Integer> weights,
                                            List<String> knowledgeIds, Pageable pageable) {
        HttpUrl.Builder urlBuilder = req.createUrlBuilder("/api/question")
                .addQueryParameter("stem", stem)
                .addQueryParameter("tag", joinComma(tags))
                .addQueryParameter("knowledgeId", joinComma(knowledgeIds))
                .addQueryParameter("type", joinComma(types != null ? types.stream().map(Enum::toString).collect(Collectors.toList()) : Collections.emptyList()))
                .addQueryParameter("weight", joinComma(weights != null ? weights.stream().map(String::valueOf).collect(Collectors.toList()) : Collections.emptyList()));
        return getQuestionVOS(pageable, urlBuilder);
    }

    @Override
    public QuestionVO createQuestion(@NotNull QuestionVO question) {
        HttpUrl httpUrl = req.createUrlBuilder("/api/question").build();
        Response response = req.post(httpUrl, req.writeRequestBody(question));
        return req.getResponseBody(response, QuestionVO.class).orElseThrow(() -> SeecoderBokException.UNWRAP_EXCEPTION);
    }

    @Override
    public List<QuestionVO> createQuestions(@NotNull List<QuestionVO> questionVOS) {
        HttpUrl httpUrl = req.createUrlBuilder("/api/questions").build();
        Response response = req.post(httpUrl, req.writeRequestBody(questionVOS));
        return req.getResponseBody(response, new TypeReference<List<QuestionVO>>() {})
                .orElseThrow(() -> SeecoderBokException.UNWRAP_EXCEPTION);
    }

    @Override
    public Optional<QuestionVO> getQuestionById(@NotBlank String questionId) {
        HttpUrl httpUrl = req.createUrlBuilder(formatUrl("/api/question/{0}", encodeValue(questionId))).build();
        Response response = req.get(httpUrl);
        return req.getResponseBody(response, QuestionVO.class);
    }

    @Override
    public QuestionVO updateQuestion(@NotNull QuestionVO question) {
        HttpUrl httpUrl = req.createUrlBuilder(formatUrl("/api/question/{0}", encodeValue(question.getId()))).build();
        Response response = req.put(httpUrl, req.writeRequestBody(question));
        return req.getResponseBody(response, QuestionVO.class).orElseThrow(() -> SeecoderBokException.UNWRAP_EXCEPTION);
    }

    @Override
    public void deleteQuestionById(@NotBlank String questionId) {
        HttpUrl httpUrl = req.createUrlBuilder(formatUrl("/api/question/{0}", questionId)).build();
        req.delete(httpUrl);
    }

    @Override
    public List<QuestionVO> getQuestionListByIds(@NotNull List<String> ids) {
        HttpUrl httpUrl = req.createUrlBuilder("/api/question-query/id")
                .addQueryParameter("id", joinComma(ids))
                .build();
        Response response = req.get(httpUrl);
        return req.getResponseBody(response, new TypeReference<List<QuestionVO>>() {})
                .orElse(Collections.emptyList());
    }

    @Override
    public List<RecordVO> createUserRecord(@NotNull List<RecordVO> records) {
        HttpUrl httpUrl = req.createUrlBuilder("/api/record").build();
        Response response = req.post(httpUrl, req.writeRequestBody(records));
        return req.getResponseBody(response, new TypeReference<List<RecordVO>>() {})
                .orElse(Collections.emptyList());
    }

    @Override
    public Page<RecordVO> getUserRecord(
            List<String> userIdList,
            List<String> questionIdList,
            List<String> recordIdList,
            Pageable pageable) {
        HttpUrl.Builder urlBuilder = req.createUrlBuilder("/api/record")
                .addQueryParameter("userId", joinComma(userIdList))
                .addQueryParameter("questionId", joinComma(questionIdList))
                .addQueryParameter("recordId", joinComma(recordIdList));
        HttpUrl httpUrl = addPageableToParams(urlBuilder, pageable).build();
        Response response = req.get(httpUrl);
        return req.getResponseBody(response, new TypeReference<RestPage<RecordVO>>() {})
                .orElse(new RestPage<>());
    }

    @Override
    public RecordQuestionVO getUserRecordQuestions(
            @NotNull String userId, Pageable pageable) {
        HttpUrl.Builder urlBuilder = req.createUrlBuilder(formatUrl("/api/record/{0}/question", userId));
        HttpUrl httpUrl = addPageableToParams(urlBuilder, pageable).build();
        Response response = req.get(httpUrl);
        return req.getResponseBody(response, RecordQuestionVO.class)
                .orElse(RecordQuestionVO.empty());
    }

    @Override
    public void collectQuestion(
            @NotBlank String userId, @NotBlank String questionId, @NotNull CollectDTO collectDTO) {
        HttpUrl httpUrl = req.createUrlBuilder(
                formatUrl("/api/user/{0}/question/{1}/collection", userId, questionId)).build();
        req.post(httpUrl, req.writeRequestBody(collectDTO));
    }

    @Override
    public void rateQuestion(
            @NotBlank String userId, @NotBlank String questionId, @NotNull RateDTO rateDTO) {
        HttpUrl httpUrl = req.createUrlBuilder(
                formatUrl("/api/user/{0}/question/{1}/rate", userId, questionId)).build();
        req.post(httpUrl, req.writeRequestBody(rateDTO));
    }

    @Override
    public Page<QuestionVO> getUserInteractiveQuestions(
            @NotBlank String userId, Boolean collect, Boolean rate, Pageable pageable) {
        HttpUrl.Builder urlBuilder = req.createUrlBuilder(formatUrl("/api/user/{0}/question", userId))
                .addQueryParameter("collection", String.valueOf(collect))
                .addQueryParameter("rate", String.valueOf(rate));
        return getQuestionVOS(pageable, urlBuilder);
    }

    @Override
    public Optional<InteractionVO> getUserInteractiveQuestion(
            @NotBlank String userId, @NotBlank String questionId) {
        HttpUrl httpUrl = req.createUrlBuilder(
                formatUrl("/api/user/{0}/question/{1}", userId, questionId)).build();
        Response response = req.get(httpUrl);
        return req.getResponseBody(response, InteractionVO.class);
    }

    @Override
    public List<InteractionVO> getUserInteractiveQuestionIn(
            @NotBlank String userId, List<String> questionIdList) {
        HttpUrl httpUrl = req.createUrlBuilder(
                formatUrl("/api/user/{0}/questionInList", userId)).build();
        Response response = req.get(httpUrl);
        return req.getResponseBody(response, new TypeReference<List<InteractionVO>>() {})
                .orElse(Collections.emptyList());
    }

    @Override
    public List<InteractionVO> getAllInteractionQuestions() {
        HttpUrl httpUrl = req.createUrlBuilder(
                formatUrl("/api/user/allInteractions")).build();
        Response response = req.get(httpUrl);
        return req.getResponseBody(response, new TypeReference<List<InteractionVO>>() {})
                .orElse(Collections.emptyList());

    }

    private Page<QuestionVO> getQuestionVOS(Pageable pageable, HttpUrl.Builder urlBuilder) {
        HttpUrl httpUrl = addPageableToParams(urlBuilder, pageable).build();
        Response response = req.get(httpUrl);
        return req.getResponseBody(response, new TypeReference<RestPage<QuestionVO>>() {})
                .orElse(new RestPage<>());
    }

    private HttpUrl.Builder addPageableToParams(HttpUrl.Builder builder, Pageable pageable) {
        return Optional.ofNullable(pageable)
                .map(notNullPageable ->
                        builder.addQueryParameter("page", String.valueOf(notNullPageable.getPageNumber()))
                                .addQueryParameter("sort", parseSort(notNullPageable.getSort()))
                                .addQueryParameter("size", String.valueOf(notNullPageable.getPageSize()))
                )
                .orElse(builder);
    }

}