import { ConfigureAPI } from "../baseWellsClient";
import {
  SummaryCount,
  SummaryItems,
  WaterDepthLimits,
  DateRange,
  MeasurementType,
  MeasurementTypeItems,
  DistanceRange,
  DoglegSeverityRange,
  WellPropertiesSummaryRequest,
  WellPropertiesSummaryItems,
  AngleRange,
} from "src";
import { rethrowAsHttpError } from "../errorHandlingUtils";
import { DurationRange } from "src/model/durationRange";

export class SummariesAPI extends ConfigureAPI {
  public welltypes = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/welltypes");

  public datumLimits = async (): Promise<DistanceRange> => {
    const path: string = this.getPath("/summaries/datum");
    return this.client
      .asyncGet<DistanceRange>(path)
      .then((response) => response.data)
      .catch((err) => {
        throw rethrowAsHttpError(err);
      });
  };

  public waterDepthLimits = async (): Promise<WaterDepthLimits> => {
    const path: string = this.getPath("/summaries/waterdepths");
    return this.client
      .asyncGet<WaterDepthLimits>(path)
      .then((response) => response.data)
      .catch((err) => {
        throw rethrowAsHttpError(err);
      });
  };

  public spudDateLimits = async (): Promise<DateRange> => {
    const path: string = this.getPath("/summaries/spuddates");
    return this.client
      .asyncGet<DateRange>(path)
      .then((response) => response.data)
      .catch((err) => {
        throw rethrowAsHttpError(err);
      });
  };

  private getSummary = async (prefix: string): Promise<SummaryCount[]> => {
    const path: string = this.getPath(prefix);
    return await this.client
      .asyncGet<SummaryItems>(path)
      .then((response) => response.data.items)
      .catch((err) => {
        throw rethrowAsHttpError(err);
      });
  };

  public measurementTypes = async (): Promise<MeasurementType[]> => {
    const path: string = this.getPath("/summaries/measurementtypes");
    return await this.client
      .asyncGet<MeasurementTypeItems>(path)
      .then((response) => response.data.items)
      .catch((err) => {
        throw rethrowAsHttpError(err);
      });
  };

  public blocks = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/blocks");
  public fields = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/fields");
  public operators = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/operators");
  public quadrants = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/quadrants");

  public ndsRiskTypes = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/nds/risktypes");

  public nptCodes = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/npt/codes");

  /**
   * @deprecated Please use .nptCodeDetails() instead
   */
  public nptDetailCodes = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/npt/codedetails");

  public nptCodeDetails = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/npt/codedetails");

  public regions = async (): Promise<SummaryCount[]> =>
    this.getSummary("/summaries/regions");

  public nptDurations = async (): Promise<DurationRange> => {
    const path: string = this.getPath(`/summaries/npt/durations`);
    return this.client
      .asyncGet<DurationRange>(path)
      .then((response) => response.data)
      .catch((err) => {
        throw rethrowAsHttpError(err);
      });
  };

  public trajectoriesMeasuredDepthLimits = async (): Promise<DistanceRange> => {
    const path: string = this.getPath("/summaries/trajectories/measureddepth");
    return this.client
      .asyncGet<DistanceRange>(path)
      .then((response) => response.data)
      .catch((err) => {
        throw rethrowAsHttpError(err);
      });
  };

  public trajectoriesTrueVerticalDepthLimits =
    async (): Promise<DistanceRange> => {
      const path: string = this.getPath(
        "/summaries/trajectories/trueverticaldepth"
      );
      return this.client
        .asyncGet<DistanceRange>(path)
        .then((response) => response.data)
        .catch((err) => {
          throw rethrowAsHttpError(err);
        });
    };

  public trajectoriesDoglegSeverityLimits =
    async (): Promise<DoglegSeverityRange> => {
      const path: string = this.getPath(
        "/summaries/trajectories/doglegseverity"
      );
      return this.client
        .asyncGet<DoglegSeverityRange>(path)
        .then((response) => response.data)
        .catch((err) => {
          throw rethrowAsHttpError(err);
        });
    };

  public trajectoriesMaximumInclinationLimits =
    async (): Promise<AngleRange> => {
      const path: string = this.getPath("/summaries/trajectories/inclination");
      return this.client
        .asyncGet<AngleRange>(path)
        .then((response) => response.data)
        .catch((err) => {
          throw rethrowAsHttpError(err);
        });
    };

  public wellProperties = async (
    request: WellPropertiesSummaryRequest
  ): Promise<WellPropertiesSummaryItems> => {
    const path = this.getPath("/summaries/wellproperties");
    return this.client
      .asyncPost<WellPropertiesSummaryItems>(path, {
        data: request,
      })
      .then((response) => response.data)
      .catch((err) => {
        throw rethrowAsHttpError(err);
      });
  };
}