import { call, put, takeEvery, takeLatest, select } from "redux-saga/effects";
import * as composer from "../composer";
import {
  FETCHING_INPUTS,
  fetchingInputsSucceeded,
  fetchingFilterNoResults,
  FETCHING_INPUT_DETAILS,
  FETCHING_INPUT_DEPS,
  FETCHING_DEP_DETAILS,
  setSelectedInput,
  setSelectedInputDeps,
  setDepDetails,
} from "../actions/inputs";
import { makeGetBlueprintById, makeGetSelectedDeps } from "../selectors";

function flattenInputs(response) {
  // duplicate inputs exist when more than one build is available
  // flatten duplicate inputs to a single item
  const previousInputs = {};
  const flattened = response.filter((item) => {
    const build = {
      version: item.builds[0].source.version,
      release: item.builds[0].release,
    };
    if (previousInputs.hasOwnProperty(item.name)) {
      // update the previousInput object with this item"s version/release
      // to make the default version/release the latest
      previousInputs[item.name] = Object.assign(previousInputs[item.name], build);
      // and remove this item from the list
      return false;
    }
    delete item.builds;
    item = Object.assign(item, build);

    previousInputs[item.name] = item;
    return true;
  });
  return flattened;
}

function* fetchInputs(action) {
  try {
    const { filter, selectedInputPage, pageSize } = action.payload;
    const wildcardsUsed = filter.value.includes("*");
    const regex = / +|, +/g;
    let filterValue = filter.value.replace(regex, ",");
    const regexStrip = /(^,+)|(,+$)/g;
    filterValue = filterValue.replace(regexStrip, "");
    filterValue = wildcardsUsed ? filterValue : `*${filterValue}*`.replace(/,/g, "*,*");
    // page is displayed in UI starting from 1 but api starts from 0
    const pageIndex = selectedInputPage - 1;
    const response = yield call(composer.listModules, filterValue, pageIndex, pageSize);
    const { total } = response;
    const inputNames = response.modules.map((input) => input.name).join(",");
    const inputs = yield call(composer.getComponentInfo, inputNames);
    const updatedInputs = flattenInputs(inputs).map((input) => {
      const inputData = {
        ui_type: "RPM",
        ...input,
      };
      return inputData;
    });
    yield put(fetchingInputsSucceeded(filter, selectedInputPage, pageSize, updatedInputs, total));
  } catch (error) {
    const { filter, pageSize } = action.payload;
    if (filter.value !== "") {
      yield put(fetchingFilterNoResults(filter, pageSize));
    } else {
      console.log("Error in fetchInputsSaga", error);
    }
  }
}

function flattenInput(response) {
  // each response item is a different build (version, release, arch)
  // flatten the response to a single item with an array of builds
  // only keep the latest release per version
  // for each version, include wildcard options
  const previousBuilds = {};
  const flattened = { ...response[0], builds: [] };
  response.forEach((item) => {
    let previousBuild;
    const build = {
      version: item.builds[0].source.version,
      release: item.builds[0].release,
      arch: [item.builds[0].arch],
    };
    if (previousBuilds.hasOwnProperty(build.version)) {
      // if this item has the same version value as a
      // previousBuild replace the release value (this is assumed to be the latest)
      // then push arch to the array of arch's and filter this item out
      previousBuild = previousBuilds[build.version];
      previousBuild.arch = previousBuild.arch.concat(build.arch);
      previousBuild.release = build.release;
      return false;
    }
    // else push the build to the array of builds
    flattened.builds = [build].concat(flattened.builds);

    previousBuilds[build.version] = build;
    return true;
  });
  flattened.builds = addWildcardVersions(flattened.builds);
  return flattened;
}

function addWildcardVersions(builds) {
  const wildcardBuilds = {};
  builds.forEach((item) => {
    item.depsolveVersion = item.version;

    const parts = item.version.split(".");
    for (let i = 0; i < parts.length; i += 1) {
      const wildcard = parts.slice(0, i).concat("*").join(".");

      if (!(wildcard in wildcardBuilds)) {
        wildcardBuilds[wildcard] = { ...item, version: wildcard };
      }
    }
    wildcardBuilds[item.version] = { ...item };
  });

  return Object.values(wildcardBuilds);
}

// when ComponentDetailsView loads, get component details
function* fetchInputDetails(action) {
  try {
    const { component } = action.payload;
    const response = yield call(composer.getComponentInfo, component.name);
    const updatedResponse = flattenInput(response);
    const componentData = {
      ...component,
      builds: updatedResponse.builds,
      description: updatedResponse.description,
      homepage: updatedResponse.homepage,
      summary: updatedResponse.summary,
    };
    yield put(setSelectedInput(componentData));
  } catch (error) {
    console.log("Error in fetchInputDetails", error);
  }
}

// when ComponentDetailsView loads, get component dependencies
function* fetchInputDeps(action) {
  try {
    const { component } = action.payload;
    const response = yield call(composer.getComponentDependencies, component.name);
    let responseIndex;
    if (response[0].builds) {
      responseIndex = response.findIndex((item) => {
        return item.builds[0].release === component.release && item.builds[0].source.version === component.version;
      });
    } else {
      responseIndex = 0;
    }
    const deps = response[responseIndex].dependencies.filter((item) => item.name !== component.name);
    const updatedDeps = deps.map((dep) => {
      const depData = {
        ui_type: "RPM",
        ...dep,
      };
      delete depData.epoch;
      delete depData.arch;
      return depData;
    });
    yield put(setSelectedInputDeps(updatedDeps));
  } catch (error) {
    console.log("Error in fetchInputDeps", error);
  }
}

// when expanding a dependency list item in ComponentDetailsView
// get additional details to display in expanded section
function* fetchDepDetails(action) {
  try {
    const { component, blueprintId } = action.payload;
    const response = yield call(composer.getComponentDependencies, component.name);
    const deps = response[0].dependencies.filter((item) => item.name !== component.name);
    const updatedDeps = deps.map((dep) => {
      const depData = { ui_type: "RPM", ...dep };
      delete depData.epoch;
      delete depData.arch;
      return depData;
    });
    const getBlueprintById = makeGetBlueprintById();
    const blueprint = yield select(getBlueprintById, blueprintId);
    const { components } = blueprint.present;

    const getSelectedDeps = makeGetSelectedDeps();
    const selectedDeps = yield select(getSelectedDeps, updatedDeps, components);

    const depDetails = {
      ...component,
      description: response[0].description,
      homepage: response[0].homepage,
      summary: response[0].summary,
      dependencies: selectedDeps,
    };
    yield put(setDepDetails(depDetails));
  } catch (error) {
    console.log("Error in fetchDepDetails", error);
  }
}

export default function* () {
  yield takeLatest(FETCHING_INPUTS, fetchInputs);
  yield takeLatest(FETCHING_INPUT_DETAILS, fetchInputDetails);
  yield takeLatest(FETCHING_INPUT_DEPS, fetchInputDeps);
  yield takeEvery(FETCHING_DEP_DETAILS, fetchDepDetails);
}