import cockpit from "cockpit";
import providerSettings from "../data/providers";

const cockpitHttp = cockpit.http("/run/weldr/api.socket", { superuser: "try" });

/*
 * Send a request to the composer API.
 *
 * `options` can contain `path`, `params`, `headers`, `body`, and
 * `replyFormat`. The ones that have the same name as cockpit.http options
 * correspond to them and are passed along.
 *
 * `replyFormat` can be set to "json" (the default) or "raw".
 *
 * All responses are expected to be either empty or valid JSON.
 */
function request(options) {
  const replyFormat = options.replyFormat || "json";

  /*
   * Wrap this in an additional Promise. The promise returned by
   * cockpit.http.request() doesn't propagate exceptions thrown in a .catch
   * handler. Thus, we need to reject() manually.
   */
  return new Promise((resolve, reject) => {
    cockpitHttp
      .request({
        method: options.method,
        path: options.path,
        params: options.params,
        headers: options.headers,
        body: options.body,
      })
      .then((data) => {
        if (replyFormat === "json") resolve(JSON.parse(data));
        else if (replyFormat === "raw") resolve(data);
        else throw new Error(`invalid replyFormat: '${replyFormat}'`);
      })
      .catch((error) =>
        reject({
          problem: error.problem,
          message: error.message,
          options,
        })
      );
  });
}

/*
 * Send a GET request to the composer API.
 */
function get(path, options) {
  return request({
    body: "",
    ...options,
    path,
  });
}

/*
 * Send a POST request to the composer API. `object` will be turned into a JSON
 * payload.
 */
function post(path, object, options) {
  return request({
    ...options,
    method: "POST",
    path,
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(object),
  });
}

/*
 * Send a DELETE request to the composer API.
 */
function _delete(path, options) {
  return request({
    ...options,
    method: "DELETE",
    path,
    body: "",
  });
}

/*
 * Wrappers for composer API calls
 */

export function newBlueprint(blueprint) {
  return post("/api/v0/blueprints/new", blueprint);
}

export function depsolveBlueprint(blueprintName) {
  return get(`/api/v0/blueprints/depsolve/${encodeURIComponent(blueprintName)}`);
}

export function listModules(filter, selectedInputPage, pageSize) {
  const page = selectedInputPage * pageSize;
  return get(`/api/v0/modules/list/${encodeURIComponent(filter)}`, {
    params: { limit: pageSize, offset: page },
  });
}

/*
 * Next two functions have a different name from their API route, because the
 * routes are confusing.
 */
export function getComponentInfo(componentNames) {
  return get(`/api/v0/projects/info/${encodeURIComponent(componentNames)}`).then((response) => response.projects);
}

export function getComponentDependencies(componentNames) {
  return get(`/api/v0/modules/info/${encodeURIComponent(componentNames)}`).then((response) => response.modules);
}

export function listBlueprints() {
  return get("/api/v0/blueprints/list").then((response) => response.blueprints);
}

export function getBlueprintInfo(blueprintName) {
  return get(`/api/v0/blueprints/info/${encodeURIComponent(blueprintName)}`).then((blueprintdata) => {
    if (blueprintdata.blueprints.length > 0) {
      const blueprint = blueprintdata.blueprints[0];
      blueprint.changed = blueprintdata.changes[0].changed;
      blueprint.id = blueprintName;
      return blueprint;
    }
  });
}

export function getComposeTypes() {
  const imageTypeLabels = {
    ami: "Amazon Machine Image Disk (.ami)",
    "ext4-filesystem": "Ext4 File System Image (.img)",
    "fedora-iot-commit": "Fedora IoT Commit (.tar)",
    "live-iso": "Live Bootable ISO (.iso)",
    "partitioned-disk": "Raw Partitioned Disk Image (.img)",
    qcow2: "QEMU QCOW2 Image (.qcow2)",
    openstack: "OpenStack (.qcow2)",
    "rhel-edge-commit": "RHEL for Edge Commit (.tar)",
    tar: "TAR Archive (.tar)",
    vhd: "Azure Disk Image (.vhd)",
    vmdk: "VMware Virtual Machine Disk (.vmdk)",
    alibaba: "Alibaba Machine Image (.qcow2)",
    google: "Google Compute Engine Image (.tar.gz)",
    "hyper-v": "Hyper-V Virtual Machine Disk (.vhdx)",
  };
  const imageTypes = get("/api/v0/compose/types").then((data) =>
    data.types.map((type) => {
      return { ...type, label: imageTypeLabels[type.name] || type.name };
    })
  );
  return imageTypes;
}

export function deleteBlueprint(blueprint) {
  return _delete(`/api/v0/blueprints/delete/${encodeURIComponent(blueprint)}`).then(() => blueprint);
}

export function deleteWorkspace(blueprintId) {
  return _delete(`/api/v0/blueprints/workspace/${encodeURIComponent(blueprintId)}`);
}

export function commitToWorkspace(blueprint) {
  return post("/api/v0/blueprints/workspace", blueprint);
}

export function diffBlueprintToWorkspace(blueprintId) {
  return get(`/api/v0/blueprints/diff/${encodeURIComponent(blueprintId)}/NEWEST/WORKSPACE`);
}

export function getSourceInfo(sourceName) {
  return get(`/api/v0/projects/source/info/${encodeURIComponent(sourceName)}`);
}

export function newSource(source) {
  return post("/api/v0/projects/source/new", source);
}

export function deleteSource(sourceName) {
  return _delete(`/api/v0/projects/source/delete/${encodeURIComponent(sourceName)}`);
}

export function startCompose(blueprintName, composeType, imageSize, ostree, uploadSettings) {
  return post("/api/v1/compose", {
    blueprint_name: blueprintName,
    compose_type: composeType,
    size: imageSize,
    ostree,
    upload: uploadSettings,
    branch: "master",
  });
}

export function cancelCompose(compose) {
  return _delete(`/api/v1/compose/cancel/${encodeURIComponent(compose)}`);
}

export function deleteCompose(compose) {
  return _delete(`/api/v1/compose/delete/${encodeURIComponent(compose)}`);
}

export function getComposeStatus(uuid) {
  return get(`/api/v1/compose/status/${encodeURIComponent(uuid)}`);
}

export function getQueuedComposes() {
  return get("/api/v1/compose/queue").then((data) => data.new.concat(data.run));
}

export function getFinishedComposes() {
  return get("/api/v1/compose/finished").then((data) => data.finished);
}

export function getFailedComposes() {
  return get("/api/v1/compose/failed").then((data) => data.failed);
}

export function getComposeLog(uuid) {
  return get(`/api/v1/compose/log/${encodeURIComponent(uuid)}`, { replyFormat: "raw" });
}

export function getUploadProviders() {
  return providerSettings;
}