import {
  Page,
  PublishedPage,
  CreatePagePayload,
  CreatePageFromCopyPayload,
  Version,
  MovePagePayload,
  RenamePagePayload,
  RecurringSchedule,
  VersionedPage,
  Schema,
  Folder,
} from '../types/api';
import { handleDelete, handleFetch, serverPath, stringifyQuery } from './helpers';
import BaseApi from './base-api';

class PageApi extends BaseApi {
  public async getAllPages(): Promise<Page[]> {
    const response = await handleFetch(`/pages/all/${this.language}`);
    return await response.json();
  }

  public async getPublishedPages(): Promise<PublishedPage[]> {
    const response = await handleFetch(`/pages/published/${this.language}`);
    return await response.json();
  }

  public async getFolders(): Promise<Folder[]> {
    const response = await handleFetch('/pages/folders');
    return await response.json();
  }

  public async getSchema(): Promise<Schema> {
    const response = await handleFetch('/versions/schema');
    return await response.json();
  }

  public async getPageById(id: string): Promise<VersionedPage> {
    const response = await handleFetch(`/pages/${id}`);
    const page = await response.json();

    page.versions = await this.getPageVersionsById(id);

    return page;
  }

  public async getPageVersionsById(id: string): Promise<Version[]> {
    const response = await handleFetch(`/pages/${id}/versions`);
    return await response.json();
  }

  public async create({ version, name, parentId }: CreatePagePayload): Promise<Page[]> {
    const path = stringifyQuery('/versions/create', { name, parentId });
    const response = await handleFetch(path, {
      method: 'post',
      body: JSON.stringify(version),
    });
    return await response.json();
  }

  public async createFromCopy(payload: CreatePageFromCopyPayload): Promise<Version> {
    const path = stringifyQuery('/versions/create-from-copy', payload);
    const response = await handleFetch(path, {
      method: 'post',
    });
    return await response.json();
  }

  public async move({ page, newParentId }: MovePagePayload): Promise<Page[]> {
    const path = stringifyQuery(`/pages/${page.id}/move`, { newParentId });
    const response = await handleFetch(path, {
      method: 'post',
    });
    return await response.json();
  }

  public async rename({ page, name }: RenamePagePayload): Promise<Page[]> {
    const path = stringifyQuery(`/pages/${page.id}/rename`, { name });
    const response = await handleFetch(path, {
      method: 'post',
    });
    return await response.json();
  }

  public async delete(page: Page): Promise<Response> {
    return await handleDelete(`/pages/${page.id}`);
  }

  public async updateVersion(version: Version): Promise<Version> {
    const response = await handleFetch(`/versions/update/${version.id}`, {
      method: 'put',
      body: JSON.stringify(version),
    });
    return await response.json();
  }

  public async publishVersion(version: Version): Promise<Version> {
    const response = await handleFetch(`/versions/publish/${version.id}`, {
      method: 'post',
    });
    return await response.json();
  }

  public async depublishVersion(version: Version): Promise<Version> {
    const response = await handleFetch(`/versions/depublish/${version.id}`, {
      method: 'post',
    });
    return await response.json();
  }

  public async copyVersion(version: Version): Promise<Version> {
    const response = await handleFetch(`/versions/copy/${version.id}`, {
      method: 'post',
    });
    return await response.json();
  }

  public async deleteVersion(version: Version): Promise<Response> {
    return await handleDelete(`/versions/${version.id}`);
  }

  public previewUrl(version: Version, versionCounter: number): string | null {
    return version.id ? `${serverPath}/versions/preview/${version.id}?counter=${versionCounter}` : null;
  }

  public async scheduledVersionIds(pageId: string): Promise<string[]> {
    const response = await handleFetch(`/pages/schedules/${pageId}`);
    return await response.json();
  }

  public async getRecurrentSchedulesForId(id: string): Promise<RecurringSchedule[]> {
    const response = await handleFetch(`/versions/schedules/${id}`);
    return await response.json();
  }

  public async scheduleDaily(schedule: RecurringSchedule): Promise<RecurringSchedule> {
    const response = await handleFetch(`/versions/schedule`, {
      method: 'post',
      body: JSON.stringify(schedule),
    });
    return await response.json();
  }

  public deleteSchedule(id: string): Promise<Response> {
    return handleFetch(`/versions/schedules/delete/${id}`);
  }
}

export default new PageApi();