/**
 * PagarmeApiSDKLib
 *
 * This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ).
 */

import { ApiResponse, RequestOptions } from '../core';
import {
  CreatePlanItemRequest,
  createPlanItemRequestSchema,
} from '../models/createPlanItemRequest';
import {
  CreatePlanRequest,
  createPlanRequestSchema,
} from '../models/createPlanRequest';
import {
  GetPlanItemResponse,
  getPlanItemResponseSchema,
} from '../models/getPlanItemResponse';
import {
  GetPlanResponse,
  getPlanResponseSchema,
} from '../models/getPlanResponse';
import {
  ListPlansResponse,
  listPlansResponseSchema,
} from '../models/listPlansResponse';
import {
  UpdateMetadataRequest,
  updateMetadataRequestSchema,
} from '../models/updateMetadataRequest';
import {
  UpdatePlanItemRequest,
  updatePlanItemRequestSchema,
} from '../models/updatePlanItemRequest';
import {
  UpdatePlanRequest,
  updatePlanRequestSchema,
} from '../models/updatePlanRequest';
import { number, optional, string } from '../schema';
import { BaseController } from './baseController';

export class PlansController extends BaseController {
  /**
   * Gets a plan
   *
   * @param planId  Plan id
   * @return Response from the API call
   */
  async getPlan(
    planId: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<GetPlanResponse>> {
    const req = this.createRequest('GET');
    const mapped = req.prepareArgs({ planId: [planId, string()] });
    req.appendTemplatePath`/plans/${mapped.planId}`;
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(getPlanResponseSchema, requestOptions);
  }

  /**
   * Deletes a plan
   *
   * @param planId          Plan id
   * @param idempotencyKey
   * @return Response from the API call
   */
  async deletePlan(
    planId: string,
    idempotencyKey?: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<GetPlanResponse>> {
    const req = this.createRequest('DELETE');
    const mapped = req.prepareArgs({
      planId: [planId, string()],
      idempotencyKey: [idempotencyKey, optional(string())],
    });
    req.header('idempotency-key', mapped.idempotencyKey);
    req.appendTemplatePath`/plans/${mapped.planId}`;
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(getPlanResponseSchema, requestOptions);
  }

  /**
   * Updates the metadata from a plan
   *
   * @param planId          The plan id
   * @param request         Request for updating the plan metadata
   * @param idempotencyKey
   * @return Response from the API call
   */
  async updatePlanMetadata(
    planId: string,
    request: UpdateMetadataRequest,
    idempotencyKey?: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<GetPlanResponse>> {
    const req = this.createRequest('PATCH');
    const mapped = req.prepareArgs({
      planId: [planId, string()],
      request: [request, updateMetadataRequestSchema],
      idempotencyKey: [idempotencyKey, optional(string())],
    });
    req.header('idempotency-key', mapped.idempotencyKey);
    req.json(mapped.request);
    req.appendTemplatePath`/Plans/${mapped.planId}/metadata`;
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(getPlanResponseSchema, requestOptions);
  }

  /**
   * Updates a plan item
   *
   * @param planId          Plan id
   * @param planItemId      Plan item id
   * @param body            Request for updating the plan item
   * @param idempotencyKey
   * @return Response from the API call
   */
  async updatePlanItem(
    planId: string,
    planItemId: string,
    body: UpdatePlanItemRequest,
    idempotencyKey?: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<GetPlanItemResponse>> {
    const req = this.createRequest('PUT');
    const mapped = req.prepareArgs({
      planId: [planId, string()],
      planItemId: [planItemId, string()],
      body: [body, updatePlanItemRequestSchema],
      idempotencyKey: [idempotencyKey, optional(string())],
    });
    req.header('idempotency-key', mapped.idempotencyKey);
    req.json(mapped.body);
    req.appendTemplatePath`/plans/${mapped.planId}/items/${mapped.planItemId}`;
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(getPlanItemResponseSchema, requestOptions);
  }

  /**
   * Adds a new item to a plan
   *
   * @param planId          Plan id
   * @param request         Request for creating a plan item
   * @param idempotencyKey
   * @return Response from the API call
   */
  async createPlanItem(
    planId: string,
    request: CreatePlanItemRequest,
    idempotencyKey?: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<GetPlanItemResponse>> {
    const req = this.createRequest('POST');
    const mapped = req.prepareArgs({
      planId: [planId, string()],
      request: [request, createPlanItemRequestSchema],
      idempotencyKey: [idempotencyKey, optional(string())],
    });
    req.header('idempotency-key', mapped.idempotencyKey);
    req.json(mapped.request);
    req.appendTemplatePath`/plans/${mapped.planId}/items`;
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(getPlanItemResponseSchema, requestOptions);
  }

  /**
   * Gets a plan item
   *
   * @param planId       Plan id
   * @param planItemId   Plan item id
   * @return Response from the API call
   */
  async getPlanItem(
    planId: string,
    planItemId: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<GetPlanItemResponse>> {
    const req = this.createRequest('GET');
    const mapped = req.prepareArgs({
      planId: [planId, string()],
      planItemId: [planItemId, string()],
    });
    req.appendTemplatePath`/plans/${mapped.planId}/items/${mapped.planItemId}`;
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(getPlanItemResponseSchema, requestOptions);
  }

  /**
   * Creates a new plan
   *
   * @param body            Request for creating a plan
   * @param idempotencyKey
   * @return Response from the API call
   */
  async createPlan(
    body: CreatePlanRequest,
    idempotencyKey?: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<GetPlanResponse>> {
    const req = this.createRequest('POST', '/plans');
    const mapped = req.prepareArgs({
      body: [body, createPlanRequestSchema],
      idempotencyKey: [idempotencyKey, optional(string())],
    });
    req.header('idempotency-key', mapped.idempotencyKey);
    req.json(mapped.body);
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(getPlanResponseSchema, requestOptions);
  }

  /**
   * Removes an item from a plan
   *
   * @param planId          Plan id
   * @param planItemId      Plan item id
   * @param idempotencyKey
   * @return Response from the API call
   */
  async deletePlanItem(
    planId: string,
    planItemId: string,
    idempotencyKey?: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<GetPlanItemResponse>> {
    const req = this.createRequest('DELETE');
    const mapped = req.prepareArgs({
      planId: [planId, string()],
      planItemId: [planItemId, string()],
      idempotencyKey: [idempotencyKey, optional(string())],
    });
    req.header('idempotency-key', mapped.idempotencyKey);
    req.appendTemplatePath`/plans/${mapped.planId}/items/${mapped.planItemId}`;
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(getPlanItemResponseSchema, requestOptions);
  }

  /**
   * Gets all plans
   *
   * @param page          Page number
   * @param size          Page size
   * @param name          Filter for Plan's name
   * @param status        Filter for Plan's status
   * @param billingType   Filter for plan's billing type
   * @param createdSince  Filter for plan's creation date start range
   * @param createdUntil  Filter for plan's creation date end range
   * @return Response from the API call
   */
  async getPlans(
    page?: number,
    size?: number,
    name?: string,
    status?: string,
    billingType?: string,
    createdSince?: string,
    createdUntil?: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<ListPlansResponse>> {
    const req = this.createRequest('GET', '/plans');
    const mapped = req.prepareArgs({
      page: [page, optional(number())],
      size: [size, optional(number())],
      name: [name, optional(string())],
      status: [status, optional(string())],
      billingType: [billingType, optional(string())],
      createdSince: [createdSince, optional(string())],
      createdUntil: [createdUntil, optional(string())],
    });
    req.query('page', mapped.page);
    req.query('size', mapped.size);
    req.query('name', mapped.name);
    req.query('status', mapped.status);
    req.query('billing_type', mapped.billingType);
    req.query('created_since', mapped.createdSince);
    req.query('created_until', mapped.createdUntil);
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(listPlansResponseSchema, requestOptions);
  }

  /**
   * Updates a plan
   *
   * @param planId          Plan id
   * @param request         Request for updating a plan
   * @param idempotencyKey
   * @return Response from the API call
   */
  async updatePlan(
    planId: string,
    request: UpdatePlanRequest,
    idempotencyKey?: string,
    requestOptions?: RequestOptions
  ): Promise<ApiResponse<GetPlanResponse>> {
    const req = this.createRequest('PUT');
    const mapped = req.prepareArgs({
      planId: [planId, string()],
      request: [request, updatePlanRequestSchema],
      idempotencyKey: [idempotencyKey, optional(string())],
    });
    req.header('idempotency-key', mapped.idempotencyKey);
    req.json(mapped.request);
    req.appendTemplatePath`/plans/${mapped.planId}`;
    req.authenticate([{ httpBasic: true }]);
    return req.callAsJson(getPlanResponseSchema, requestOptions);
  }
}