/* Copyright CloudLinux Zug GmbH 2010-2017 All Rights Reserved
 *
 * Licensed under CLOUD LINUX LICENSE AGREEMENT
 * http://cloudlinux.com/docs/LICENSE.TXT
 */

import { Row, Cell, Field } from '../utils/row';
import { TranslateClass } from '../utils/pipes/translate';
import { Helper } from '../utils/helper';
import { ViewModes, PS_CREATED_BY_RESELLER } from '../services/view_modes';
import { AppState } from '../app.service';
import { CellsMap, FieldProperties, getFieldValueString } from '../utils/types';
import { packageProperties } from '../utils/componentProperties/packageProperties';
import { packageColumnInfo } from '../utils/componentProperties/columnExtendedProperties';

export class Package extends Row {

  package_name: any = null;
  provider: any = null;
  enabledLimits: boolean;
  packageTypeTooltip: string;
  limits_cpu_all: any = null;
  limits_vmem: any = null;
  limits_pmem: any = null;
  limits_ep: any = null;
  limits_nproc: any = null;
  limits_iops: any = null;
  limits_io_all: any = null;
  limits_inodes_hard: any = null;
  limits_inodes_soft: any = null;
  editable: boolean;
  defaultPackageName: string = 'VE_DEFAULT';

  protected _packageType: string;
  get packageType(): string {
    return this._packageType;
  }
  set packageType(value: string) {
    if (typeof value === 'undefined') return;

    this._packageType = value;
    this.packageTypeTooltip = ViewModes.availableModesForPackages().find((mode) => {
      return mode.name === this.packageType;
    }).title.tooltip;
  }

  get isUnderReseller(): boolean {
    return (
        this.packageType === PS_CREATED_BY_RESELLER
        && this.appState.get('isAdmin')
    );
  }

  constructor(response: any, i: number, private appState: AppState){
    super();
    this.loadData(response, i);
  }

  public loadData(response: any, i: number, editing: boolean = false){
    let package_info = response['package'][i];
    this.package_name = package_info['package'];
    this.provider = package_info['provider'];

    this.enabledLimits = !!(package_info['enabledLimits']);

    this.packageType = package_info.packageType;

    for (let columnInfo of packageColumnInfo) {
        if (package_info.limits.hasOwnProperty(columnInfo.descr.toLowerCase())) {
            let value = package_info['limits'][columnInfo.descr.toLowerCase()];
            if (columnInfo.objField) value = value[columnInfo.objField];
            this[columnInfo.name] = columnInfo.units ?
                Helper.reformatValue(value, columnInfo.units) : value;
        }
    }

    if (package_info.package === this.defaultPackageName) {
      this.editable = false;
      this.tooltip = new TranslateClass()
          .transform('To change limits for VE_DEFAULT package, ' +
              'please change limits for DEFAULT user.');
    } else {
      this.editable = true;
    }
    this.editing = editing;

    this.cells  = this.prepareCellForPackage(response, editing);
  }

  public prepareCellForPackage(response: any, editing: boolean): CellsMap {
    let cells: CellsMap = {};
    for (let packageFieldsKey of Object.keys(packageProperties)) {
        let value = this[packageFieldsKey];
        if (value !== null) {
            let params: FieldProperties = <FieldProperties>packageProperties[packageFieldsKey];
            params.value = value;
            cells[packageFieldsKey] = new Cell([new Field(params)]);
        }
    }
    return cells;
  }

  validate(column: string, lineNumber: number) {
    let line = this.cells[column].lines[lineNumber];
    let stateOfErrorBeforeValidation = line.error;
    line.resetErrors();

    for (let validator of line.requirements) {
        let value: string = line.stringValue;
     if (validator.p) {
        validator.p.unshift(value.replace(/ /g, ''));
      } else {
        validator.p = [value.replace(/ /g, '')];
      }

      let result = validator.m.apply(null, validator.p);

      if (!result['isOK']) {
        line.addError(result['message']);
      }
    }

    if (line.errorMessages.length) {
      line.error = true;
      this.hasError = true;
      line.tooltipTextError = line.errorMessages.join('. ') + '.';
    } else {
      line.tooltipTextError = '';
      if (!this.hasRowError()) {
        this.resetError();
      }
    }
  }

}