import type { HetznerAccount } from './classes.account.js';
import type { HetznerServer } from './classes.server.js';
import * as plugins from './hetznercloud.plugins.js';
import * as types from './types.js';

export class HetznerVolume {
  public static create = async (
    hetznerAccountRefArg: HetznerAccount,
    optionsArg: {
      name: string;
      size: number;
      location: types.THetznerCloudLocationName;
      labels?: {[key: string]: string},
      server: HetznerServer,
    }
  ) => {
    const volume = new HetznerVolume(hetznerAccountRefArg);

    const createVolumeUrl = '/volumes';
    const createVolumePayload: types.TVolumeCreateRequestBody = {
      name: optionsArg.name,
      size: optionsArg.size,
      location: optionsArg.location,
      labels: optionsArg.labels || {} as any,
      server: optionsArg.server.data.id,
      format: 'xfs'
    };
    const response = await volume.hetznerAccountRef.request(
      'POST',
      createVolumeUrl,
      createVolumePayload
    );
    volume.data = (response.body as types.TVolumeCreateResponseBody).volume;
    return volume;
  }

  public static getVolumes = async (hetznerAccountRefArg: HetznerAccount) => {
    const volumesGetUrl = '/volumes';
    const response = await hetznerAccountRefArg.request('GET', volumesGetUrl, {});
    const volumesDataArray = (response.body as types.TVolumeGetResponseBody).volumes;
    const volumes: HetznerVolume[] = [];
    for (const volumeData of volumesDataArray) {
      const volume = new HetznerVolume(hetznerAccountRefArg);
      volume.data = volumeData;
      volumes.push(volume);
    }
    return volumes;
  }

  public static getVolumesByLabel = async (hetznerAccountRefArg: HetznerAccount, labelObject: {[key: string]: string}) => {
    const volumes = await HetznerVolume.getVolumes(hetznerAccountRefArg);
    const results: HetznerVolume[] = [];
    for (const volume of volumes) {
      let isMatch = true;
      for (const key in labelObject) {
        if (volume.data.labels[key] !== labelObject[key]) {
          isMatch = false;
        }
      }
      if (isMatch) {
        results.push(volume);
      }
    }
    return results;
  }

  public data: types.IVolume;
  public hetznerAccountRef: HetznerAccount;

  constructor(hetznerAccountRefArg: HetznerAccount) {
    this.hetznerAccountRef = hetznerAccountRefArg;
  }

  public delete = async () => {
    await this.hetznerAccountRef.request('DELETE', `/volumes/${this.data.id}`, {});
  }
}