import { hashAPIPath } from "../../../actions/core/hash";
import { getToken } from "../../../actions/core/token";
import { azureHeaders } from "../../../actions/core/headers";
import { consoleLogger } from "../../../actions/core/logger";
import axios from "axios";
import { respondError, respondSuccess } from "../middleware/apiResponse";
import { getServerSession } from "next-auth/next";
import { authOptions } from "../auth/[...nextauth]";

import nextConnect from "next-connect";
import middleware from "../middleware/middleware";

const ApiProxy = nextConnect();
ApiProxy.use(middleware);

const BASE_URL = process.env.API_ROOT || `http://localhost:${port}`;

const hasValue = (value) =>
    typeof value === "string" && value.trim().length > 0;

const isValidContainer = (value) =>
    typeof value === "string" &&
    value.length >= 3 &&
    value.length <= 63 &&
    /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(value);

const isValidTempCaseRef = (value) =>
    typeof value === "string" &&
    value.length <= 100 &&
    !value.includes("..") &&
    /^[A-Za-z0-9](?:[A-Za-z0-9/-]*[A-Za-z0-9])?$/.test(value);

const forbidden = (res) =>
    respondError(res, {
        status: 403,
        code: "FORBIDDEN",
        message: "Request not permitted"
    });

ApiProxy.get(async (req, res) => {
    const containerName = req.query.container;
    const tempCaseRef = req.query.tempcaseref;

    if (!hasValue(containerName) || !hasValue(tempCaseRef)) {
        return respondError(res, {
            status: 400,
            code: "MISSING_REQUIRED_QUERY",
            message: "container and tempcaseref are required"
        });
    }

    if (
        !isValidContainer(containerName) ||
        !isValidTempCaseRef(tempCaseRef)
    ) {
        return respondError(res, {
            status: 400,
            code: "INVALID_REQUEST",
            message: "Invalid request"
        });
    }

    const session = await getServerSession(req, res, authOptions(req, res));
    if (
        typeof session?.user?.id !== "string" ||
        session.user.id.length === 0 ||
        session.user.id !== containerName
    ) {
        return forbidden(res);
    }

    const token = await getToken();

    const queryUrl =
        "/api/file/createappealcompletemessage_api?container=" +
        encodeURIComponent(containerName) +
        "&tempcaseref=" +
        encodeURIComponent(tempCaseRef);

    try {
        const requestOptions = azureHeaders(token.access_token);
        if (typeof req.headers?.cookie === "string") {
            requestOptions.headers = {
                ...requestOptions.headers,
                cookie: req.headers.cookie
            };
        }

        const { data } = await axios.get(
            BASE_URL + queryUrl + hashAPIPath(queryUrl),
            requestOptions
        );
        return respondSuccess(res, data);
    } catch (error) {
        consoleLogger(error);
        return respondError(res, {
            status: 400,
            code: "CREATE_APPEAL_COMPLETE_MESSAGE_PROXY_FAILED",
            message: "Failed to create appeal complete message"
        });
    }
});

export const config = {
    api: {
        bodyParser: false
    }
};

export default ApiProxy;