ota-admin-portal/src/components/Contexts/CarUpdatesContext.jsx

import React, { useContext, useState } from "react";

import api from "../../services/updates";

const CarUpdatesContext = React.createContext();

const validateDeployCarUpdates = (data) => {
  if (data === null) {
    throw new Error("No car update data");
  }

  if (!data.manifest_id || data.manifest_id === 0) {
    throw new Error("Manifest id required");
  }

  if (!data.vins || data.vins.length === 0) {
    throw new Error("Cars are required");
  }
};

export const CarUpdatesProvider = ({ children }) => {
  const [busy, setBusy] = useState(false);
  const [carUpdates, setCarUpdates] = useState([]);
  const [totalCarUpdates, setTotalCarUpdates] = useState(0);
  const [delayCount, setDelayCount] = useState(0);
  let progressTimer = 0;

  const deployCarUpdates = async (data, token) => {
    let result;

    try {
      setBusy(true);
      validateDeployCarUpdates(data);
      result = await api.createCarUpdates(data, token);
      if (result.error)
        throw new Error(`Deploy car updates error. ${result.message}`);
    } finally {
      setBusy(false);
    }

    return result;
  };

  const getCarUpdates = async (search, token) => {
    let result;

    try {
      setBusy(true);
      result = await api.getCarUpdates(search, token);
      if (result.error)
        throw new Error(`Get car updates error. ${result.message}`);
      setCarUpdates(result.data);
      if (search && search.offset === 0 && result.total) {
        setTotalCarUpdates(result.total);
      }
    } finally {
      setBusy(false);
    }

    return result;
  };

  const getVINUpdates = async (vin, token) => {
    let result;

    try {
      setBusy(true);
      result = await api.getVINUpdates(vin, token);
      if (result.error)
        throw new Error(`Get VIN updates error. ${result.message}`);
    } finally {
      setBusy(false);
    }

    return result;
  };

  const applyProgressStatus = (item, status) => {
    if (status.msg === "package_download_complete") {
      delete item.progress;
      item.status = "downloaded";
    } else if (status.msg === "downloading" && status.package_total > 0) {
      let progress = Math.floor(
        (100 * status.package_current) / status.package_total
      );
      if (progress > 99) progress = 0;
      item.progress = progress;
      item.status = `downloading ${progress}%`;
    } else if (status.error > 0 || status.msg === "download_error") {
      item.status = "download error";
    } else {
      item.status = "downloading";
    }
  };

  const applyProgressStatuses = (statuses) => {
    let items = JSON.parse(JSON.stringify(carUpdates));

    statuses.forEach((status) => {
      let item = items.find((item) => status.id === item.id);
      if (!item || status.id === 0) return;
      applyProgressStatus(item, status);
    });

    setCarUpdates(items);
  };

  const updateStatusProgress = async (token) => {
    stopMonitor();

    if (!token || carUpdates.length === 0) return;

    try {
      setBusy(true);
      const carupdateids = carUpdates.reduce((accum, update) => {
        if (update.status !== "downloaded") accum.push(update.id);
        return accum;
      }, []);
      if (carupdateids.length === 0) return;

      const result = await api.getCarUpdateProgress(
        carupdateids.join(","),
        token
      );
      if (result.error)
        throw new Error(`Get update progress error. ${result.message}`);

      applyProgressStatuses(result.statuses);
    } catch (e) {
    } finally {
      setBusy(false);
    }
  };

  const getDelay = () => {
    if (delayCount < 3) {
      setDelayCount(delayCount + 1);
      return 1000;
    }
    for (let i = 0, len = carUpdates.length; i < len; i++) {
      if (carUpdates[i].status.indexOf("downloading") > -1) return 1000;
    }
    return 10000;
  };

  const startMonitor = async (token) => {
    const delay = getDelay();
    stopMonitor();
    progressTimer = setTimeout(() => {
      updateStatusProgress(token);
    }, delay);
  };

  const stopMonitor = async () => {
    if (progressTimer === 0) return;
    clearTimeout(progressTimer);
    progressTimer = 0;
  };

  return (
    <CarUpdatesContext.Provider
      value={{
        busy,
        carUpdates,
        totalCarUpdates,
        deployCarUpdates,
        getCarUpdates,
        getVINUpdates,
        startMonitor,
        stopMonitor,
      }}
    >
      {children}
    </CarUpdatesContext.Provider>
  );
};

export const useCarUpdatesContext = () => useContext(CarUpdatesContext);