export class Paginator {

  public unit = 'Items';

  private _currentPage: number;
  private _totalUnits: number;
  private _unitsPerPage: number;

  constructor (unitName: string,
      unitsPerPage: number,
      total: number,
      current?: number) {
    this.unit = unitName;
    this.setUnitsPerPage(unitsPerPage || 10);
    this.setTotalUnits(total || 0);
    this.setCurrentPage(current || 1);
  }

  public getTotalUnits (): number {
    return this._totalUnits;
  }

  public setTotalUnits (total: number): void {
    this._totalUnits = total;
    // Need to recalc since page nums are changing
    this._recalculatePagination();
  }

  public getTotalPages (): number{
    return Math.ceil(this.getTotalUnits() / this.getUnitsPerPage());
  }

  public getUnitsPerPage (): number {
    return this._unitsPerPage;
  }

  public setUnitsPerPage (units: number): void {
    // Only recalc if units per page changes
    if (units != this._unitsPerPage) {
      this._unitsPerPage = units;
      this._recalculatePagination();
    }
  }

  public getCurrentPage (): number {
    return this._currentPage;
  }

  public setCurrentPage (pageNum: number): void {
    if (this._isValidPageNum(pageNum)) {
      this._currentPage = pageNum;
    }
  }
  
  public nextPage (): void {
    this.setCurrentPage(this._currentPage + 1);
  }

  public previousPage (): void {
    this.setCurrentPage(this._currentPage - 1);
  }

  public printDisplayingString (): string {
    const [min, max] =
      this._calculateDisplayedUnits(this._currentPage);

    return `${min} – ${max} of ${this.getTotalUnits()}`;
  }

  public printPerPageString (): string {
    return `${this.unit} per page`;
  }

  private _isValidPageNum (pageNum): boolean {
    if (pageNum < 1 || this._exceedsTotal(pageNum)) {
      return false;
    } else {
      return true;
    }
  }

  private _exceedsTotal (pageNum): boolean {
    const r = this._calculateRemainder(pageNum);

    return r > 0 && r > this.getUnitsPerPage();
  }

  private _calculateRemainder (pageNum): number {
    return (pageNum * this.getUnitsPerPage())
      - this.getTotalUnits();
  }

  private _calculateDisplayedUnits (currentPage): number[] {
    const maxUnit = this._calculateMaxUnits(currentPage);
    const minUnit = this._calculateMinUnits(currentPage);

    return [minUnit, maxUnit];
  }

  private _calculateMaxUnits (currentPage): number {
    const max = this.getUnitsPerPage() * currentPage;
    const total = this.getTotalUnits();

    return max > total ? total : max;
  }

  private _calculateMinUnits (currentPage): number {
    const units = this.getUnitsPerPage();
    const min = ((units * currentPage) - units) + 1;
    const max = this._calculateMaxUnits(currentPage);

    return min > max ? max : min;
  }

  private _recalculatePagination (): void {
    // Call when units per page or total units change
    this._currentPage = 1;
  }
}