import {
  Page,
  PublishedPage,
  CreatePagePayload,
  CreatePageFromCopyPayload,
  Version,
  MovePagePayload,
  RenamePagePayload,
  RecurringSchedule,
  VersionedPage,
  Schema,
  Folder,
  PageReferenceInfo,
  CreateTranslatedPagePayload
} from '../types/api';
import { handleDelete, handleFetch, getServerPath, stringifyQuery } from './helpers';
import PageTree from '../tools/page-tree';
import { CrudSearchReponse, ITEMS_PER_PAGE } from './crud-api';

export default class PageApi {
  public static async getPages(clickedPageIds: string[]): Promise<Page[]> {
    const path = stringifyQuery('/pages/load', { clickedPageIds });

    const response = await handleFetch(path);
    return await response.json();
  }

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

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

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

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

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

    return page;
  }

  public static async isLeafFolder(id: string): Promise<boolean> {
    const response = await handleFetch(`/pages/${id}/is-leaf-folder`);
    return await response.json();
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  public static search(query: string, allowedTypes: string[]) {
    const path = stringifyQuery(`/pages/search`, { query, allowedTypes });
    return handleFetch(path)
      .then((res) => res.json())
      .then((pages) => new PageTree(pages as Page[]).items);
  }

  public static async searchCrud(query?: string, language?: string, page?: number, sort?: string): Promise<CrudSearchReponse> {
    const queryParams = {
      query: query || '',
      page: page || 1,
      itemsPerPage: ITEMS_PER_PAGE,
      language: language || '',
      sort: sort || ''
    };

    const path = stringifyQuery(`/pages/crud/search`, queryParams);
    const response = await handleFetch(path);

    return await response.json();
  }

  public static async setLanguage(page: Page, language: string) {
    const path = stringifyQuery(`/pages/${page.id}/set-language`, { language });
    const response = await handleFetch(path, {
      method: 'post'
    });
    return await response.json();
  }

  public static async getReferenceInfoForVersion(versionId: string): Promise<PageReferenceInfo> {
    const response = await handleFetch(`/versions/reference-info/${versionId}`);
    return await response.json();
  }
}