import { Component, Input, Output, EventEmitter, OnChanges } from '@angular/core';
import { RdLib } from '../../base/rdLib';
import { ServerSidePagingProxy, ServerSidePagingRequest, ServerSidePagingResponse } from '../../base/serviceCall';
import { ServiceProviderPagingBase, IProviderContent } from './serviceProviderPagingBase';

@Component({
  selector: 'rd-service-provider:[rd-server-side-paging]',
  template: ""
})
export class ServiceProviderServerSide extends ServiceProviderPagingBase implements OnChanges {
  @Input("rd-service-proxy") serviceProxy: ServerSidePagingProxy;
  @Input("rd-page-size") pageSize = 10;

  @Output("rd-success") successEvent: EventEmitter<IProviderContent> = new EventEmitter<IProviderContent>();
  @Output("rd-error") errorEvent: EventEmitter<IProviderContent> = new EventEmitter<IProviderContent>();

  ngOnChanges(changes) {
    if (changes.serviceProxy) {
      if (!(this.serviceProxy instanceof ServerSidePagingProxy)) this.error("rd-service-proxy is not an instance of ServerSidePagingProxy");
    }
    if (changes.pageSize) {
      this.pageSize = changes.pageSize.currentValue;
      if (this.content.state.serviceCalled) this.gotoPage(1);
    }
  }

  call(params) {
    this.internalGetData(params, 1);
  }

  gotoPage(pageNumber) {
    this.internalGetData(this.content.params, pageNumber);
  };

  refresh() {
    this.gotoPage(this.content.paging.currentPage);
  };

  private internalGetData(params, pageNumber) {
    if (this.content.state.waitingForResponse) return;
    this.callState(params, ServerSidePagingProxy);

    this.internalCall(params, this.pageSize, pageNumber).then(response => {
      this.successState(response);

      this.content.items = response.items;
      this.content.paging = {
        currentPage: pageNumber,
        totalPageCount: response.totalPageCount,
        pageSize: this.pageSize,
        totalItemCount: response.totalItemCount
      };

      this.successEvent.emit(this.content);
    })
      .catch(() => {
        this.errorState();
        this.errorEvent.emit(this.content);
      });
  }

  private internalCall(params, pageSize, pageNumber): Promise<ServerSidePagingResponse> {
    return new Promise((resolve, reject) => {
      var request = new ServerSidePagingRequest();
      request.params = params;
      request.pageSize = pageSize;
      request.pageNumber = pageNumber;

      this.serviceProxy.call(request, response => resolve(response), () => reject());
    });
  }

  getAllItems(progressCallback = (currentIteration, totalIterationCount) => { }): Promise<any[]> {
    if (!this.content.state.serviceCalled) return Promise.reject(null);

    var params = RdLib.objectOperations.deepCopy(this.content.params);
    var currentPage = 0;
    var totalPage = 1;
    var allItems = [];

    var iterateCall = function (resolve, reject) {
      if (currentPage >= totalPage) {
        resolve(allItems);
        return;
      }

      currentPage++;
      this.internalCall(params, 1000, currentPage).then(response => {
        progressCallback(currentPage, response.totalPageCount);
        totalPage = response.totalPageCount;
        allItems = allItems.concat(response.items);
        iterateCall(resolve, reject);
      })
        .catch(() => {
          reject();
          return;
        });
    }.bind(this);

    return new Promise((resolve, reject) => iterateCall(resolve, reject));
  }
}