import { Request, ResponseToolkit } from "@hapi/hapi";
import { SeaQAService } from "../services/seaQA.service";
import { Common } from "../../utils/common";

export class SeaQAHandler {
    private getSeaQAServiceObject = async (request: Request) => {
        let variables = await Common.getVariables(request);
        return new SeaQAService(variables);
    };

    askQuestion = async (request: Request, h: ResponseToolkit) => {
        const payload = request.payload as SeaQAQuestionRequest;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.askQuestion(payload);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }


    getQuestionDetail = async (request: Request, h: ResponseToolkit) => {
        const { id } = request.params;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.getQuestionDetail(+id);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    listQuestions = async (request: Request, h: ResponseToolkit) => {
        const query = request.query as any;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.listQuestions(query);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    adminQuestionAction = async (request: Request, h: ResponseToolkit) => {
        const payload = request.payload as SeaQAQuestionAdminActionRequest;
        const seaQAService = await this.getSeaQAServiceObject(request);
        await seaQAService.adminQuestionsAction(payload);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY" });
    }

    markAsGoodQuestion = async (request: Request, h: ResponseToolkit) => {
        const { id } = request.params;
        const { isGood } = (request.payload || {}) as any;
        const seaQAService = await this.getSeaQAServiceObject(request);
        await seaQAService.markAsGoodQuestion(+id, !!isGood);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY" });
    }

    postAnswer = async (request: Request, h: ResponseToolkit) => {
        const { questionId } = request.params;
        const payload = request.payload as SeaQAAnswerRequest;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.postAnswer(+questionId, payload);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    updateAnswer = async (request: Request, h: ResponseToolkit) => {
        const { id } = request.params;
        const payload = request.payload as SeaQAAnswerUpdateRequest;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.updateAnswer(+id, payload);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    deleteAnswer = async (request: Request, h: ResponseToolkit) => {
        const { id } = request.params;
        const seaQAService = await this.getSeaQAServiceObject(request);
        await seaQAService.deleteDraftAnswer(+id);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY" });
    }

    adminAnswerAction = async (request: Request, h: ResponseToolkit) => {
        const payload = request.payload as SeaQAAnswerAdminActionRequest;
        const seaQAService = await this.getSeaQAServiceObject(request);
        await seaQAService.adminAnswersAction(payload);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY" });
    }

    markAsFeaturedAnswer = async (request: Request, h: ResponseToolkit) => {
        const { id } = request.params;
        const { isFeatured } = (request.payload || {}) as any;
        const seaQAService = await this.getSeaQAServiceObject(request);
        await seaQAService.markAsFeaturedAnswer(+id, !!isFeatured);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY" });
    }

    postComment = async (request: Request, h: ResponseToolkit) => {
        const { answerId } = request.params;
        const payload = request.payload as SeaQACommentRequest;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.postComment(+answerId, payload);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    getComments = async (request: Request, h: ResponseToolkit) => {
        const { answerId } = request.params;
        const query = request.query as any;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.getComments(+answerId, query);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    listComments = async (request: Request, h: ResponseToolkit) => {
        const query = request.query as any;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.listComments(query);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    toggleBookmark = async (request: Request, h: ResponseToolkit) => {
        const { entityId, entityType } = request.params;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.toggleBookmark(+entityId, entityType as any);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData: { isBookmarked: responseData } });
    }

    listBookmarks = async (request: Request, h: ResponseToolkit) => {
        const { entityType, page, perPage, sortBy, sortDirection } = request.query as any;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const userId = (request.auth.credentials as any).userData.userId;
        const responseData = await seaQAService.listBookmarks(userId, entityType, page, perPage, sortBy, sortDirection);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    toggleLike = async (request: Request, h: ResponseToolkit) => {
        const { entityId, entityType } = request.params;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.toggleLike(+entityId, entityType as any);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData: { isLiked: responseData } });
    }

    followTopic = async (request: Request, h: ResponseToolkit) => {
        const { categoryId } = request.params;
        const seaQAService = await this.getSeaQAServiceObject(request);
        await seaQAService.followTopic(+categoryId);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY" });
    }

    unfollowTopic = async (request: Request, h: ResponseToolkit) => {
        const { categoryId } = request.params;
        const seaQAService = await this.getSeaQAServiceObject(request);
        await seaQAService.unfollowTopic(+categoryId);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY" });
    }

    getFollowedTopics = async (request: Request, h: ResponseToolkit) => {
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.getFollowedTopics();
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    updateCategoryApplicability = async (request: Request, h: ResponseToolkit) => {
        const { categoryId } = request.params;
        const payload = request.payload as CategoryApplicabilityRequest;
        const seaQAService = await this.getSeaQAServiceObject(request);
        await seaQAService.updateCategoryApplicability(+categoryId, payload);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY" });
    }

    listAnswers = async (request: Request, h: ResponseToolkit) => {
        const query = request.query as any;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.getAnswerList(query);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    listQuestionsAll = async (request: Request, h: ResponseToolkit) => {
        const query = request.query as any;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.getQuestionListAll(query);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    listPublicQuestions = async (request: Request, h: ResponseToolkit) => {
        const query = request.query as any;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.listPublicQuestions(query);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    getPublicQuestionDetail = async (request: Request, h: ResponseToolkit) => {
        const { code } = request.params;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.getPublicQuestionDetail(code);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    updateQuestion = async (request: Request, h: ResponseToolkit) => {
        const { id } = request.params;
        const payload = request.payload as SeaQAQuestionUpdateRequest;
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.updateQuestion(+id, payload, request.auth.credentials);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }

    deleteQuestion = async (request: Request, h: ResponseToolkit) => {
        const { id } = request.params;
        const seaQAService = await this.getSeaQAServiceObject(request);
        await seaQAService.deleteDraftQuestion(+id);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY" });
    }

    requestAnswer = async (request: Request, h: ResponseToolkit) => {
        const { id } = request.params;
        const payload = request.payload as { userIds: number[] };
        const seaQAService = await this.getSeaQAServiceObject(request);
        const responseData = await seaQAService.requestAnswer(+id, payload.userIds);
        return h.response({ message: "REQUEST_PROCESSED_SUCCESSFULLY", responseData });
    }
}