import { Resource } from './resource'
import { EntityUtils } from './entity-utils'
import { WebApiError, ConfigurationError } from '../core/error'
import { ListResponse, ListResponseStructure, PaginatedListResponseStructure, PaginatedListResponse, Paginated, Pagination, Sortable } from './lists'

/**
 * @export
 * @class ResourceUtils
 */
export class ResourceUtils {

  /**
   * @static
   * @template TResponse 
   * @param {Resource} resource 
   * @param {any} params 
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallGet<TResponse>(resource: Resource, params: any): Promise<TResponse> {
    return ResourceUtils.CallGetWithSuffix(resource, null, params);
  }

  /**
   * @static
   * @template TResponse 
   * @param {Resource} resource 
   * @param {string} pathSuffix 
   * @param {any} params 
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallGetWithSuffix<TResponse>(
    resource: Resource,
    pathSuffix: string,
    params: any): Promise<TResponse> {
    return ResourceUtils.CallApiWithSuffix(resource, pathSuffix, "GET", params);
  }

  /**
   * @static
   * @template TRequest 
   * @template TResponse 
   * @param {Resource} resource 
   * @param {TRequest=} payload
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallCreate<TRequest, TResponse>(
    resource: Resource,
    payload?: TRequest): Promise<TResponse> {
    return ResourceUtils.CallCreateWithSuffix(resource, null, payload);
  }

  /**
   * @static
   * @template TRequest 
   * @template TResponse 
   * @param {Resource} resource 
   * @param {string} pathSuffix 
   * @param {TRequest=} payload
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallCreateWithSuffix<TRequest, TResponse>(
    resource: Resource,
    pathSuffix: string,
    payload?: TRequest): Promise<TResponse> {
    return ResourceUtils.CallApiWithSuffix(resource, pathSuffix, "POST", null, payload, null);
  }

  /**
   * @static
   * @template TRequest 
   * @template TResponse 
   * @param {Resource} resource 
   * @param {TRequest=} payload
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallUpdate<TRequest, TResponse>(
    resource: Resource,
    payload?: TRequest): Promise<TResponse> {
    return ResourceUtils.CallUpdateWithSuffix(resource, null, payload);
  }

  /**
   * @static
   * @template TRequest 
   * @template TResponse 
   * @param {Resource} resource 
   * @param {string} pathSuffix 
   * @param {TRequest=} payload
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallUpdateWithSuffix<TRequest, TResponse>(
    resource: Resource,
    pathSuffix: string,
    payload?: TRequest): Promise<TResponse> {
    return ResourceUtils.CallApiWithSuffix(resource, pathSuffix, "PUT", null, payload, null);
  }

  /**
   * @static
   * @template TResponse 
   * @param {Resource} resource 
   * @param {any} params 
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallDelete<TResponse>(resource: Resource, params: any): Promise<TResponse> {
    return ResourceUtils.CallDeleteWithSuffix(resource, null, params);
  }

  /**
   * @static
   * @template TResponse 
   * @param {Resource} resource 
   * @param {string} pathSuffix 
   * @param {any} params 
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallDeleteWithSuffix<TResponse>(
    resource: Resource,
    pathSuffix: string,
    params: any): Promise<TResponse> {
    return ResourceUtils.CallApiWithSuffix(resource, pathSuffix, "DELETE", params);
  }

  /**
   * @template TResponse 
   * @param {Resource} resource 
   * @param {string} pathSuffix 
   * @param {string} method 
   * @param {any=} params 
   * @param {Uint8Array} data 
   * @param {any=} headers
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public UploadDataWithSuffix<TResponse>(
    resource: Resource,
    pathSuffix: string,
    method: string,
    params: any,
    data: Uint8Array,
    headers?: any): Promise<TResponse> {
    return ResourceUtils.CallApiWithSuffix(resource, pathSuffix, method, params, data, headers)
  }

  /**
   * @static
   * @template TData 
   * @template TResponse 
   * @param {Resource} resource 
   * @param {string} pathSuffix 
   * @param {string} method 
   * @param {any=} params
   * @param {TData=} data
   * @param {any=} headers
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallDownload<TData, TResponse>(
    resource: Resource,
    pathSuffix: string,
    method: string,
    params?: any,
    data?: TData,
    headers?: any
  ): Promise<TResponse> {
    return ResourceUtils.CallApiWithSuffix(resource, pathSuffix, method, params, data, headers, 'arraybuffer');
  }

  /**
   * @static
   * @template TData 
   * @template TResponse 
   * @param {Resource} resource 
   * @param {string} pathSuffix 
   * @param {string} method 
   * @param {any=} params
   * @param {TData=} data
   * @param {any=} headers
   * @param {string=} responseType
   * @returns {Promise<TResponse>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallApiWithSuffix<TData, TResponse>(
    resource: Resource,
    pathSuffix: string,
    method: string,
    params?: any,
    data?: TData,
    headers?: any,
    responseType?: string): Promise<TResponse> {
    var url = pathFromResource(resource, pathSuffix);
    return resource.getClient().callApi(url, method, params, data, headers, responseType);
  }

  /**
   * @static
   * @template TItem 
   * @param {Resource} resource 
   * @param {string} pathSuffix 
   * @param {string=} itemsKey
   * @param {any=} params
   * @param {function=} responseTransform
   * @returns {Promise<PaginatedListResponse<TItem>>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallPaginatedListWithSuffix<TItem>(
    resource: Resource,
    pathSuffix: string,
    itemsKey?: string,
    params?: any,
    responseTransform?: (response: PaginatedListResponse<TItem>) => PaginatedListResponse<TItem>): Promise<PaginatedListResponse<TItem>> {

    var parameters = {};
    if (params) {
      params = EntityUtils.copyData(params);
      //TODO: Extract to ListParamUtils
      if (ListRequestUtils.isPaginated(params)) {
        params["size"] = params.pageSize
        params["page"] = params.pageNumber
        delete params.pageNumber;
        delete params.pageSize;
      }

      if (ListRequestUtils.isSortable(params)) {
        if (Array.isArray(params['sort'])) {
          params['sort'] = (<string[]>params['sort']).join(',');
        }

        if (Array.isArray(params['order'])) {
          (params['order'] as any) = (<string[]>params['order']).join(',');
        }
      }

      //Copy the rest
      for (var k in params) parameters[k] = params[k];
    }
    var promise = ResourceUtils.CallApiWithSuffix(resource, pathSuffix, "GET", params, null, null).then(function (data) {
      var listStructure = new PaginatedListResponseStructure<TItem>();

      if (itemsKey) {
        listStructure.items = data[itemsKey]
      } else {
        listStructure.items = <any>data;
      }

      if (!listStructure.items) {
        (<any>listStructure).items = [];
      }

      listStructure.pagination = ListRequestUtils.paginationFromListData(data);
      listStructure.nextPage = (): Promise<PaginatedListResponseStructure<TItem>> => {
        var nextPageParams = EntityUtils.copyData(parameters);
        nextPageParams["page"] = listStructure.pagination.nextPage;
        var promise: any = ResourceUtils.CallPaginatedListWithSuffix(resource, pathSuffix, itemsKey, nextPageParams, responseTransform)
        return promise
      }
      listStructure.prevPage = (): Promise<PaginatedListResponseStructure<TItem>> => {
        var prevPageParams = EntityUtils.copyData(parameters);
        prevPageParams["page"] = listStructure.pagination.prevPage;
        if (prevPageParams["page"] === null) {
          return Promise.reject(new WebApiError("You cannot call prevPage on page 0"));
        }
        var promise: any = ResourceUtils.CallPaginatedListWithSuffix(resource, pathSuffix, itemsKey, prevPageParams, responseTransform);
        return promise;
      }

      return responseTransform(listStructure);
    });
    return promise;
  }

  /**
   * @static
   * @template TItem 
   * @param {Resource} resource 
   * @param {string} pathSuffix 
   * @param {string=} itemsKey
   * @param {any=} params
   * @returns {Promise<ListResponse<TItem>>} 
   * 
   * @memberOf ResourceUtils
   */
  public static CallListWithSuffix<TItem>(
    resource: Resource,
    pathSuffix: string,
    itemsKey?: string,
    params?: any): Promise<ListResponse<TItem>> {

    var parameters = {};
    if (params) {

      if (ListRequestUtils.isSortable(params)) {
        if (Array.isArray(params['sort'])) {
          params['sort'] = (<string[]>params['sort']).join(',');
        }

        if (Array.isArray(params['order'])) {
          (params['order'] as any) = (<string[]>params['order']).join(',');
        }
      }

      //Copy the rest
      for (var k in params) parameters[k] = params[k];
    }
    var promise = ResourceUtils.CallApiWithSuffix(resource, pathSuffix, "GET", params, null, null).then(function (data) {
      var listStructure = new ListResponseStructure<TItem>();

      if (itemsKey) {
        listStructure.items = data[itemsKey]
      } else {
        listStructure.items = <any>data;
      }

      if (!listStructure.items) {
        (<any>listStructure).items = [];
      }

      return listStructure;
    });
    return promise;
  }
}

function pathFromResource(resource: Resource, appendix: string): string {
  if (appendix == null) {
    return resource.getPath()
  }
  return resource.getPath() + "/" + appendix;
}

/**
 * @class ListRequestUtils
 */
class ListRequestUtils {

  /**
   * @static
   * @param {any} params 
   * @returns {params is Paginated} 
   * 
   * @memberOf ListRequestUtils
   */
  static isPaginated(params: any): params is Paginated {
    return params.pageNumber != null && params.pageSize != null;
  }

  /**
   * @static
   * @param {any} params 
   * @returns {params is Sortable} 
   * 
   * @memberOf ListRequestUtils
   */
  static isSortable(params: any): params is Sortable<any> {
    return params.sort != null && params.order != null;
  }

  /**
   * @static
   * @param {any} data 
   * @returns {Pagination} 
   * 
   * @memberOf ListRequestUtils
   */
  static paginationFromListData(data: any): Pagination {
    if (data["pageNumber"] !== undefined) {
      var pagination = new PaginationStructure();
      pagination.pageNumber = data["pageNumber"];
      pagination.pageCount = data["pageCount"];
      pagination.pageSize = data["pageSize"];
      pagination.nextPage = data["nextPage"];
      pagination.prevPage = data["pageNumber"] === 0 ? null : data["pageNumber"] - 1;
      pagination.hasNextPage = typeof (data["nextPage"]) === "number" && pagination.pageNumber !== pagination.nextPage;
      pagination.hasPrevPage = typeof (data["pageNumber"]) === "number" && pagination.pageNumber !== 0;
      return pagination;
    }
    return null;
  }
}

/**
 * @class PaginationStructure
 * @implements {Pagination}
 */
class PaginationStructure implements Pagination {
  pageNumber: number;
  pageSize: number;
  pageCount: number;
  nextPage: number;
  prevPage: number;
  hasNextPage: boolean;
  hasPrevPage: boolean;
}