import { Headers, Http, Response } from '@angular/http';
import { IGetRowsParams } from 'ag-grid/main';

import { Observable } from 'rxjs/Observable';
import 'rxjs/add/operator/toPromise';
import 'rxjs/add/operator/map';

export abstract class StatementBaseService {
    protected abstract url: string;
    protected headers: Headers = new Headers({'Content-Type': 'application/json'});

    constructor(protected http: Http) { }

    getData(params: IGetRowsParams): Promise<any[]> {
      let sort: string = null;
      if (params.sortModel.length) {
        sort = this.parseSort(params.sortModel[0]);
      }
      let url: string = this.url;
      url += '?from=' + params.startRow + '&perPage=' + (params.endRow - params.startRow);
      if (sort) {
              url += '&sort=' + sort;
          }
      let filter: string = this.parseFilter(params.filterModel);
      if (filter) {
        url += '&filter=' + filter;
      }
      return this.http.get(url)
              .toPromise()
              .then((response: Response) => {
                let data: any[] = this.parseModels(response.json());
                if (!data.length) {
                      data = [this.createModel()];
                  }
                let lastRow: number = -1;
                if (data.length < (params.endRow-params.startRow)) {
                      lastRow = params.startRow+data.length;
                  }
                params.successCallback(data, lastRow);
                return data;
              })
              .catch(this.handleError);
    }

  // getData(params: IGetRowsParams): Observable<any[]> {
  //   let sort: string = null;
  //   if (params.sortModel.length) {
  //     sort = this.parseSort(params.sortModel[0]);
  //   }
  //   let url: string = this.url;
  //   url += '?from=' + params.startRow + '&perPage=' + (params.endRow - params.startRow);
  //   if (sort) {
  //           url += '&sort=' + sort;
  //       }
  //   let filter: string = this.parseFilter(params.filterModel);
  //   if (filter) {
  //     url += '&filter=' + filter;
  //   }
  //   return this.http.get(url)
  //             .map((response: Response) => this.parseModels(response.json()));
  // }

  update(id: number, data: string): Promise<any> {
    return this.http.post(this.url + '/update?id=' + id, data, { headers: this.headers })
      .toPromise()
      .then((response: Response) => response.json())
      .catch(this.handleError);
  }

  create(data: string): Promise<any> {
    return this.http.post(this.url + '/create', data, { headers: this.headers })
      .toPromise()
      .then((response: Response) => this.parseModel(response.json()))
      .catch(this.handleError);
  }

  delete(id: number): Promise<any> {
    return this.http.delete(this.url + '/delete?id=' + id, { headers: this.headers })
      .toPromise()
      .then((response: Response) => response.json())
      .catch(this.handleError);
  }

  public abstract createModel(): Object;

  protected handleError(error: any): Promise<any> {
    console.error('An error occured', error);
    return Promise.reject(error.message || error);
  }

  protected parseSort(sort: any): string {
      if (sort.colId && sort.sort) {
          let result = sort.colId;
          if (sort.sort === 'desc') {
              result = '-' + result;
          }
          return result;
      }
      return null;
  }

  protected parseFilter(filter: Object): string {
    let result: string = '';
    for (let property in filter) {
      let value: string = filter[property].filter;
      let operator: string = filter[property].type;
      let symbol: string;
      switch (operator) {
        case 'contains':
          symbol = '*';
          break;
        case 'equals':
          symbol = '=';
          break;
        case 'notEquals':
          symbol = '!';
          break;
        case 'startsWith':
          symbol = '^';
          break;
        case 'endsWith':
          symbol = '$';
          break;
        default:
      }
      if (symbol.length) {
        result += symbol + property + '_' + value + ';';
      }
    }
    if (result.length) {
      return result;
    } else {
      return null;
    }
  }

  protected abstract parseModels(json: any): any[];
  protected abstract parseModel(json: any): any;
}