import { Plan, UserData } from "@kumori/aurora-interfaces";


interface HandlePlanInstanceEventParams {
  entityId: string;
  eventData: any;
  parentParts: { [entity: string]: string };
}

interface HandlePlanInstanceEventResult {
  plan: Plan;
  planKey: string;
}
interface UpdateUserPlansParams {
  newPlan: Plan;
  userData: UserData;
  userId: string;
}

interface UpdateUserPlansResult {
  shouldUpdate: boolean;
  updatedPlans: Plan[];
}

/**
 * Handles the "planinstance" event from WebSocket messages
 * Processes plan data and builds the Plan object
 */
export const handlePlanInstanceEvent = ({
  entityId,
  eventData,
  parentParts,
}: HandlePlanInstanceEventParams): HandlePlanInstanceEventResult => {
  const planProvider = parentParts.planprovider;
  const planKey = `${planProvider}/${entityId}`;

  const newPlan: Plan = {
    name: entityId,
    provider: planProvider,
    alias: eventData.spec.alias || "",
    lastCheck: eventData.spec.lastCheck
      ? eventData.spec.lastCheck.toString()
      : "",
    tenants: eventData.status.tenants
      ? Object.keys(eventData.status.tenants)
      : [],
    quarantine: eventData.spec.quarantine || false,
    owner: eventData.spec.owner || "",
    limits: eventData.spec.limits
      ? {
          cpu: eventData.spec.limits.vcpu || 0,
          memory: eventData.spec.limits.memory || 0,
          instances: eventData.spec.limits.instances || 0,
          deployments: eventData.spec.limits.deployments || 0,
          tenants: eventData.spec.limits.tenants || 0,
          accounts: eventData.spec.limits.accounts || 0,
          clusters: eventData.spec.limits.clusters || 0,
          nrstorage: eventData.spec.limits.nrstorage || 0,
          rstorage: eventData.spec.limits.rstorage || 0,
          vstorage: eventData.spec.limits.vstorage || 0,
          storage: eventData.spec.limits.storage || 0,
        }
      : undefined,
    type: eventData.spec.type || "",
  };

  return {
    plan: newPlan,
    planKey,
  };
};

/**
 * Updates user plans after a plan event
 * Only updates if the user is the owner of the plan
 */
export const updateUserPlansAfterPlanEvent = ({
  newPlan,
  userData,
  userId,
}: UpdateUserPlansParams): UpdateUserPlansResult => {
  if (newPlan.owner !== userId) {
    return {
      shouldUpdate: false,
      updatedPlans: userData.plans || [],
    };
  }

  const updatedPlans = userData.plans || [];
  const existingIndex = updatedPlans.findIndex(
    (plan) => plan.name === newPlan.name && plan.provider === newPlan.provider
  );

  if (existingIndex !== -1) {
    updatedPlans[existingIndex] = newPlan;
  } else {
    updatedPlans.push(newPlan);
  }

  return {
    shouldUpdate: true,
    updatedPlans,
  };
};