<cfsetting showdebugoutput="false">
<cfsetting enablecfoutputonly="true">
<cfcontent type="application/json; charset=utf-8" reset="true">

<cfscript>
// Manually trigger a scheduled task (for testing)
// Creates a task from the scheduled task definition without updating next run time
// Input: BusinessID (required), ScheduledTaskID (required)
// Output: { OK: true, TASK_ID: int }

function apiAbort(required struct payload) {
    writeOutput(serializeJSON(payload));
    abort;
}

function readJsonBody() {
    var raw = getHttpRequestData().content;
    if (isNull(raw)) raw = "";
    if (!len(trim(raw))) return {};
    try {
        var data = deserializeJSON(raw);
        if (isStruct(data)) return data;
    } catch (any e) {}
    return {};
}

try {
    data = readJsonBody();

    // Get BusinessID
    businessID = 0;
    httpHeaders = getHttpRequestData().headers;

    if (structKeyExists(data, "BusinessID") && isNumeric(data.BusinessID)) {
        businessID = int(data.BusinessID);
    } else if (structKeyExists(httpHeaders, "X-Business-ID") && isNumeric(httpHeaders["X-Business-ID"])) {
        businessID = int(httpHeaders["X-Business-ID"]);
    }

    if (businessID == 0) {
        apiAbort({ "OK": false, "ERROR": "missing_params", "MESSAGE": "BusinessID is required" });
    }

    // Get scheduled task ID
    scheduledTaskID = structKeyExists(data, "ScheduledTaskID") && isNumeric(data.ScheduledTaskID) ? int(data.ScheduledTaskID) : 0;

    if (scheduledTaskID == 0) {
        apiAbort({ "OK": false, "ERROR": "missing_params", "MESSAGE": "ScheduledTaskID is required" });
    }

    // Get scheduled task definition
    qDef = queryExecute("
        SELECT
            ScheduledTaskTitle as Title,
            ScheduledTaskDetails as Details,
            ScheduledTaskCategoryID as CategoryID,
            ScheduledTaskTypeID as TypeID
        FROM ScheduledTaskDefinitions
        WHERE ScheduledTaskID = :id AND ScheduledTaskBusinessID = :businessID
    ", {
        id: { value: scheduledTaskID, cfsqltype: "cf_sql_integer" },
        businessID: { value: businessID, cfsqltype: "cf_sql_integer" }
    }, { datasource: "payfrit" });

    if (qDef.recordCount == 0) {
        apiAbort({ "OK": false, "ERROR": "not_found", "MESSAGE": "Scheduled task not found" });
    }

    // Create the task
    queryExecute("
        INSERT INTO Tasks (
            TaskBusinessID, TaskCategoryID, TaskTypeID,
            TaskTitle, TaskDetails, TaskStatusID, TaskAddedOn,
            TaskSourceType, TaskSourceID
        ) VALUES (
            :businessID, :categoryID, :typeID,
            :title, :details, 0, NOW(),
            'scheduled_manual', :scheduledTaskID
        )
    ", {
        businessID: { value: businessID, cfsqltype: "cf_sql_integer" },
        categoryID: { value: qDef.CategoryID, cfsqltype: "cf_sql_integer", null: isNull(qDef.CategoryID) },
        typeID: { value: qDef.TypeID, cfsqltype: "cf_sql_integer", null: isNull(qDef.TypeID) },
        title: { value: qDef.Title, cfsqltype: "cf_sql_varchar" },
        details: { value: qDef.Details, cfsqltype: "cf_sql_longvarchar", null: isNull(qDef.Details) },
        scheduledTaskID: { value: scheduledTaskID, cfsqltype: "cf_sql_integer" }
    }, { datasource: "payfrit" });

    qNew = queryExecute("SELECT LAST_INSERT_ID() as newID", [], { datasource: "payfrit" });

    apiAbort({
        "OK": true,
        "TASK_ID": qNew.newID,
        "MESSAGE": "Task created from scheduled task (manual trigger)"
    });

} catch (any e) {
    apiAbort({
        "OK": false,
        "ERROR": "server_error",
        "MESSAGE": e.message
    });
}
</cfscript>