import {
    RefObj,
    BaseAsset,
    PackageSpec,
    PackageAsset,
  } from "../../../model/assets-model.js";
  import { KindEnums } from "@apic/api-model/common/StudioEnums.js";
  import { AssetCacheModel } from "../../../model/asset-cache-model.js";
  import {
    checkForNullOrUndefined,
    isNullOrUndefined,
  } from "../../common/data-helper.js";
  import { showWarning } from "./../../common/message-helper.js";
  
  const addAssetRefValuesForPackageKind = (
    refObjects: RefObj[],
    kind: KindEnums,
    result: AssetCacheModel[]
  ) => {
    if (!isNullOrUndefined(refObjects)) {
      refObjects.forEach((iter) => {
        if (!isNullOrUndefined(iter.$ref)) {
          result.push({
            kind,
            ref: iter.$ref,
            isNewlyAdded: true,
          });
        }
      });
    }
  };

const getRefsFromPackageAsset = (asset: BaseAsset): AssetCacheModel[] => {
    const packageAsset = asset as unknown as PackageAsset;
    const spec: PackageSpec = packageAsset.spec;
    const result: AssetCacheModel[] = [];
    try {
      checkForNullOrUndefined(packageAsset, "Asset is null or undefined");
  
      // apis check
      if (Array.isArray(spec["apis"])) {
        const apiRefs: RefObj[] = spec["apis"].map(
          (api) => ({
            $ref: api.$ref || "",
          })
        );
        addAssetRefValuesForPackageKind(apiRefs, KindEnums.API, result);
      }
  
      // plans check
      if (Array.isArray(spec["plans"])) {
        const planRefs: RefObj[] = spec["plans"].map(
          (plan) => ({
            $ref: plan.$ref || "",
          })
        );
        addAssetRefValuesForPackageKind(planRefs, KindEnums.Plan, result);
      }
  
      return result;
    } catch (error: unknown) {
      showWarning((error as Error).message);
      return [];
    }
  };

  export{ getRefsFromPackageAsset}