import {
  BehaviorSubject,
  combineLatest as observableCombineLatest,
  empty as observableEmpty,
  Observable,
  of as observableOf,
  ReplaySubject,
  Subject,
  timer as observableTimer,
} from "rxjs";

import {
  catchError,
  debounceTime,
  distinctUntilChanged,
  map,
  mergeMap,
  switchMap,
  takeUntil,
  withLatestFrom,
} from "rxjs/operators";
import {
  ChangeDetectorRef,
  Component,
  Input,
  OnDestroy,
  OnInit,
  ViewChild,
} from "@angular/core";
import { ActivatedRoute, Router } from "@angular/router";
import { LazyLoadEvent } from "../../../components/primeng/common/lazyloadevent";
import { availableValues, IMarketListService } from "./imarketlist.service";

import * as uriTemplates_ from "uri-templates";
import {
  WidgetComponent,
  WidgetConfiguration,
  WidgetConfigure,
  WidgetId,
  WidgetInput,
  WidgetOutput,
} from "../../widget.metadata";
import { FormControl, NgForm } from "@angular/forms";
import { Result, ResultResource } from "../../interfaces/list.interfaces";
import { MatDialog } from "@angular/material/dialog";
import { getOrDefault, WidgetConfig } from "../../widget.configuration";
import { deepCopy, UtilService } from "../../../components/util/util.service";
import { NgUnsubscribe } from "../../../ng-unsubscribe";
import { ScrollService } from "../../../components/scroll/scroll.service";
import { ProgressbarService } from "../../../components/progressbar/progressbar.service";
import { CustomNotificationService } from "../../../components/notification/customnotification.service";
import { CurrentLocaleService } from "../../../components/i18n/currentLocale.service";
import {
  DeletionMode,
  Scope,
} from "../../../components/local-storage/local-storage-constants";
import {
  LocalStorageEntry,
  LocalStorageService,
} from "../../../components/local-storage/local-storage.service";
import { TranslateService } from "@ngx-translate/core";
import { EditAttributeService } from "../../../components/edit-attribute/edit-attribute.service";
import { Attribute } from "../../../components/edit-attribute/attribute";
import { Action } from "../../../components/hal/action";
import {
  ChangeAttributeLink,
  ChangeAttributeType,
  ChangeFieldValue,
} from "./imarketlist.interface";
import { DialogService } from "../../../components/dialog/dialog.service";

const uriTemplates = uriTemplates_;

declare var $;

declare var jQuery: any;

interface UriParams {
  timestamp?: number;
  template?: any;
  offset?: number;
  limit?: number;
  sort?: string;
  filter?: string[];
  [key: string]: any;
}

@WidgetComponent("nm-imarket-list")
@Component({
  selector: "nm-imarket-list",
  templateUrl: "./imarketlist.component.html",
  styleUrls: ["./imarketlist.component.scss"],
  host: {
    "(window:keydown.passive)": "keydown($event)",
    "(window:keyup.passive)": "keyup($event)",
  },
  providers: [EditAttributeService],
})
export class ImarketListComponentWidget implements OnInit, OnDestroy {
  @ViewChild("dt") datatable: any;
  @ViewChild("rowForm") rowForm: NgForm;

  static QUERY_PARAMS_CONTD =
    "{&page,offset,limit,filter*,sort,data-locale,locale}";
  static QUERY_PARAMS_START =
    "{?page,offset,limit,filter*,sort,data-locale,locale}";

  public selectedViewmode: string = "table";
  public isViewmodeList: boolean = false;
  public results: Subject<Result[]> = new BehaviorSubject([]);
  public mappedResults: Observable<Result[]>;
  public multiselectaction: Subject<any> = new BehaviorSubject({});
  public multiselectpayload: Subject<any> = new BehaviorSubject({});
  public isMultiselectActionNeeded: boolean = false;

  public cols: Subject<any[]> = new BehaviorSubject([]);
  public lookups: any;

  public slidevalue: number = 3;
  public boxWidth: string = "33%";
  public boxHeight: string = "220px";
  public contentVisible: boolean = true;
  public totalresults: Result[] = [];
  public lasttotalresults: Result[] = [];
  public selectedRows: Result[] = [];
  public selectedRowsOnShift: Result[] = [];
  public expandedRows: any[] = [];
  public shiftIsPressed: boolean;
  public firstLoad: boolean = true;
  public externalResource: boolean = false;
  public clientPaging: boolean = false;
  public template: any;
  public profile: string;
  public hideOnEmpty: boolean = false;
  public autoexpand: boolean = false;
  public cssClass: string;
  public header: string;
  public filterChanged: boolean = false;
  public keepSettingsAfterChangeViewMode: boolean = false;
  public lastPrimeNGEvent: LazyLoadEvent = {};
  public refresh: any;
  public debounceTime: number = 500;
  public editedActionRow: { data?: any; index?: number } = {};
  public enableAdd: boolean = false;
  public enableDownload: boolean = false;
  public newRow: any = {};
  public dataRecieved = false;
  public mpValuesMap: Map<number, availableValues[]> = new Map<
    number,
    availableValues[]
  >();
  public attributesMap: Map<string, Attribute> = new Map<string, Attribute>();
  public filteredValues: availableValues[] = [];
  public currentLink: string;
  public countDescription: string = "";
  public skuPageRedirection: boolean = false;
  public mpValueSearchTerm: FormControl = new FormControl();
  public showCustomError: boolean = false;
  public selectionEventFired: boolean = false;
  public first: number = 0;
  public selectionMode: string;
  public returnListData: boolean;
  public dataOutputted: any = {};
  public columns: { [key: string]: any } = {};
  public customFilterOptions = {};
  public date: any;
  public disableHeaderTooltip: boolean = true;
  public requestStarted: boolean = false;
  private requestRunning = false;
  private hideEmptyNotifitaion;
  public addRowInvalid: boolean = true;
  public enableSaveRow: boolean = false;
  public showRowPreview: boolean = false;
  public selectConfig;
  public infoPlacement: string;
  private _links = {};
  private editAttributeLinkParams: any;
  public withHeader = true;
  public addRowComment: boolean;
  public badLinkNotificationTitle: string;
  public badLinkNotificationMessage: string;
  public firstDayOfWeek: number;

  @WidgetId()
  public _id;

  @WidgetOutput("total")
  public total: BehaviorSubject<number> = new BehaviorSubject(0);

  @Input("info-text")
  public infoText: string = "list.results";

  public wikiLink: string;

  public title: string;

  @Input("inputLink") inputLink: string;

  @Input("dataType") dataType: string = "products";

  @WidgetInput()
  public input = new Subject<any>();

  @WidgetInput("reset")
  public resetChannel = new Subject<any>();

  @WidgetOutput("onEdit")
  public onEdit = new Subject<any>();

  @WidgetOutput("rowPreview")
  public rowPreview = new Subject<any>();

  @WidgetConfiguration()
  public configuration: WidgetConfig;

  @WidgetOutput("searchLink")
  public searchLink: BehaviorSubject<string> = new BehaviorSubject<string>(
    null
  );

  @WidgetOutput("rowIdentifier")
  public rowIdentifier: Subject<any> = new ReplaySubject<any>(1);

  @WidgetInput("updatedRowId")
  public updatedRowId: Subject<any> = new Subject<any>();

  private _uriParams: UriParams;

  @Input("uriParams")
  public set uriParams(params: any) {
    this._uriParams = <UriParams>params;
  }

  public get uriParams(): any {
    return this._uriParams;
  }

  @WidgetInput("uri")
  private inputChannel: ReplaySubject<any> = new ReplaySubject<any>();

  @WidgetInput("attributesUri")
  private attributesUri: ReplaySubject<any> = new ReplaySubject<any>();

  @WidgetInput("postURI")
  private postURI: ReplaySubject<any> = new ReplaySubject<any>();

  @WidgetInput("downloadURI")
  private downloadURI: ReplaySubject<any> = new ReplaySubject<any>();

  @WidgetInput("modeischanged")
  private modeIsChangedChannel: Subject<any> = new Subject<any>();

  @WidgetInput("reload")
  private reloadChannel: Subject<any> = new Subject<any>();

  @WidgetInput("clearSelection")
  private clearSelectionChannel: Subject<any> = new Subject<any>();

  @WidgetInput("profile")
  private profileChannel: Subject<any> = new Subject<any>();

  @WidgetOutput("selectedItems")
  private selectedItems: Subject<any> = new Subject<any>();

  @WidgetInput("inputListData")
  private inputListData: Subject<any> = new Subject<any>();

  @WidgetOutput("listDataLoaded")
  private listDataLoaded: Subject<any> = new Subject<any>();

  @WidgetOutput("addNewRow")
  private addNewRow: Subject<any> = new Subject<any>();

  @WidgetOutput("newRowObject")
  private newRowObject: Subject<any> = new Subject<any>();

  @WidgetOutput("editedRowsArray")
  private editedRowsArray: Subject<any> = new Subject<any>();

  @WidgetInput()
  public selectedLocale = new ReplaySubject<any>();

  @WidgetInput()
  public selectedUiLocale = new ReplaySubject<any>();

  @WidgetInput()
  public showProgressBar = new BehaviorSubject<boolean>(true);

  @WidgetInput()
  public identifierArray = new ReplaySubject<any>();

  @WidgetInput()
  public disableList = new ReplaySubject<any>();

  @WidgetInput()
  public customFilters = new ReplaySubject<any>();

  @WidgetInput()
  public virtualSelectUri = new ReplaySubject<any>();

  @WidgetInput()
  public editAttributesUri = new Subject<any>();

  @WidgetInput("editAttributeLinkParameters")
  private editAttributeLinkParameters: ReplaySubject<any> = new ReplaySubject<any>(
    1
  );

  /**
   * Edit attribute element value changed
   */
  @WidgetOutput("editAttributeValueChanged")
  private editAttributeValueChanged: Subject<any> = new Subject<any>();

  @WidgetInput("readOnlyMode")
  private readOnlyMode: Subject<boolean> = new Subject<boolean>();

  @WidgetOutput()
  private invalidRowExists: Subject<boolean> = new Subject<boolean>();

  private onChange: Subject<any> = new Subject<any>();
  private checkDisableStatus: Subject<any> = new Subject<any>();
  private lastUriLocalStorage: LocalStorageEntry;

  private offset: number;
  public limit: number;
  private sort: string;
  private filter: string[];
  private style: string;

  private dropdownAttributes: boolean = false;

  public selectedLocaleString: string = "";
  public selectedUiLocaleString: string = "";
  private dateOptions = {
    year: "numeric",
    month: "numeric",
    day: "numeric",
    hour: "numeric",
    minute: "numeric",
  } as const;
  public showListOverlay: Boolean = false;
  public tableHeight: number = 0;

  private unsubscribe = NgUnsubscribe.create();

  constructor(
    private listService: IMarketListService,
    private router: Router,
    private route: ActivatedRoute,
    private _scrollService: ScrollService,
    private _progressbarService: ProgressbarService,
    private _notificationService: CustomNotificationService,
    private currentLocaleService: CurrentLocaleService,
    public dialog: DialogService,
    private localStorageService: LocalStorageService,
    private translateService: TranslateService,
    public _editAttributeService: EditAttributeService,
    private _changeDetectorRef: ChangeDetectorRef
  ) {
    //In case a former call was aborted
    //this._progressbarService.requestFinished();
    this.selectedViewmode = "table";
    this.mappedResults = this.results.pipe(
      withLatestFrom(this.cols),
      map((data) => {
        const rows = data[0];
        const cols = data[1];
        if (cols.length == 0 || rows.length == 0) {
          return [];
        } else {
          rows.forEach((row) => {
            for (let i = 0; i < cols.length; i++) {
              const col = cols[i];
              const field = row[col.field];

              if (
                col.field === "variants" &&
                field !== "undefined" &&
                field[0].variantIdentifier === "OneSize"
              ) {
                this.skuPageRedirection = true;
              }
              if (field == undefined) {
                continue;
              }
              if (col.type) {
                row[col.field] = this.mapField(field, col.type);
              }
            }
          });
        }
        return rows;
      })
    );
  }

  @WidgetConfigure()
  protected configureWidget(configuration: WidgetConfig) {
    if (
      configuration.configuration["isListviewEnabled"] &&
      localStorage.getItem("nm-isViewmodeList")
    ) {
      this.isViewmodeList =
        localStorage.getItem("nm-isViewmodeList") === "true";
    }
    this.cssClass = configuration.configuration["cssClass"] || "";
    this.header = configuration.configuration["header"] || "primary";
    this.hideOnEmpty = configuration.configuration["hideOnEmpty"] || false;
    this.profile = configuration.configuration["default-profile"];
    this.cols.next(
      configuration.configuration["profiles"][
        configuration.configuration["default-profile"]
      ]
    );
    this.dataType = configuration.configuration["dataType"];
    this.infoText = configuration.configuration["infoText"];
    this.infoPlacement = configuration.configuration["infoPlacement"] || "left";
    this.title = this.configuration.configuration["title"];
    this.wikiLink = this.configuration.configuration["wikiLink"];
    this.slidevalue = this.configuration.configuration["slidevalue"];

    this.externalResource = configuration.configuration["externalResource"];
    this.clientPaging =
      configuration.configuration["clientPaging"] !== undefined
        ? configuration.configuration["clientPaging"]
        : false;
    this.debounceTime =
      configuration.configuration["debounceTime"] !== undefined
        ? parseInt(configuration.configuration["debounceTime"])
        : 500;
    this.enableAdd = configuration.configuration["enableAdd"];
    this.enableDownload = configuration.configuration["enableDownload"];
    this.limit = configuration.configuration["rowLimit"] || 10;
    this.selectionMode = configuration.configuration["selectionMode"] || null;
    this.returnListData =
      configuration.configuration["returnListData"] || false;

    this.autoexpand = configuration.configuration["autoexpand"]
      ? configuration.configuration["autoexpand"]
      : false;
    this.refresh = configuration.configuration["refresh"];
    this.countDescription =
      configuration.configuration["countDescription"] || "";
    this.lastUriLocalStorage = this.localStorageService.getLocalStorageEntry(
      "last-uri-" + this.title,
      Scope.GLOBAL,
      DeletionMode.RESET
    );
    this.hideEmptyNotifitaion =
      configuration.configuration["hideEmptyNotifitaion"] || false;
    this.enableSaveRow = configuration.configuration["enableSaveRow"] || false;
    this.showRowPreview =
      configuration.configuration["showRowPreview"] || false;
    this.selectConfig = configuration.configuration["selectConfig"];
    this.addRowComment = getOrDefault(
      configuration.configuration.addRowComment,
      false
    );
    this.badLinkNotificationTitle = getOrDefault(
      configuration.configuration["badLinkNotificationTitle"],
      "title.imarketList.error.inactive-link.error"
    );
    this.badLinkNotificationMessage = getOrDefault(
      configuration.configuration["badLinkNotificationMessage"],
      "message.imarketList.error.inactive-link.error"
    );

    this.firstDayOfWeek = getOrDefault(
      configuration.configuration.firstDayOfWeek,
      1
    );
    if (this.configuration.configuration["withHeader"] != undefined) {
      this.withHeader = this.configuration.configuration["withHeader"];
    }

    if (configuration.configuration.editAttributesLink) {
      this.initializeAttributesMap(
        configuration.configuration.editAttributesLink
      );
      if (!configuration.configuration.onlyNewRowEditable) {
        this.dropdownAttributes = true;
      }
    }

    if (this.refresh) {
      let timer = observableTimer(this.refresh, this.refresh);
      timer.pipe(takeUntil(this.unsubscribe)).subscribe((t) => {
        this.expandedRows = [].concat(this.datatable.expandedRows);
        this.reload(true);
      });
    }

    this.editAttributesUri
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((link) => {
        this.initializeAttributesMap(link);
        if (!configuration.configuration.onlyNewRowEditable) {
          this.dropdownAttributes = true;
        }
      });

    observableCombineLatest(
      this.disableList.asObservable(),
      this.checkDisableStatus.asObservable()
    )
      .pipe(takeUntil(this.unsubscribe))
      .subscribe(([disable, check]) => {
        if (this.dataRecieved) {
          setTimeout(() => {
            this.tableHeight = document.getElementsByClassName(
              "nm-widgetframe__content"
            )[0]["offsetHeight"];
            this.showListOverlay = disable;
          }, 2);
        }
      });

    this.customFilters
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((filters) => {
        this.customFilterOptions = filters;
      });

    this.selectedLocale
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((selectedLocale) => {
        this.selectedLocaleString = selectedLocale;
        this.reload();
      });

    this.selectedUiLocale
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((selectedUiLocale) => {
        this.selectedUiLocaleString = selectedUiLocale;
        this.reload();
      });

    this.profileChannel
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((profile) => {
        this.profile = profile;
        this.cols.next(configuration.configuration["profiles"][profile]);
      });

    this.clearSelectionChannel
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((reload) => {
        this.selectedRows = [];
        this.isMultiselectActionNeeded = false;
      });

    this.reloadChannel
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((reload) => {
        this.reload(true);
      });

    this.inputListData
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((inputData) => {
        this.mapResult(this.dataOutputted);
        this.dataRecieved = true;
        this.checkDisableStatus.next();
        this._progressbarService.requestFinished();
      });

    this.resetChannel
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((reset) => {
        this.lastUriLocalStorage.clear();

        this.currentLink = null;
        this.lastPrimeNGEvent = {};
        this.lastPrimeNGEvent.filters = {};

        this.sort = "";
        this.filter = [];
        localStorage.setItem("nm-pageno-" + this.title, "0");
        localStorage.setItem(
          "nm-limit-" + this.title,
          configuration.configuration["rowLimit"] || 10
        );

        if (this.datatable) {
          this.datatable.reset();
        }
        this.limit = configuration.configuration["rowLimit"] || 10;

        this.inputChannel.next(null);
      });

    this.modeIsChangedChannel
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((isChanged) => {
        if (this.datatable) {
          this.datatable.reset();
        }
        this.reload();
      });

    this.inputChannel
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((link) => {
        console.log("Link", link);
        this.clearSelectionChannel.next();
        if (link === null || link === undefined) {
          this.total.next(null);
          this.results.next([]);
        } else {
          //this._progressbarService.requestFinished();
          this.total.next(null);
          this.currentLink = link;
          let queryParams =
            link.indexOf("?") >= 0
              ? ImarketListComponentWidget.QUERY_PARAMS_CONTD
              : ImarketListComponentWidget.QUERY_PARAMS_START;
          this.currentLink =
            link.indexOf("filter*") >= 0 ? link : link + queryParams;
          this.offset = 0;
          this.totalresults = [];

          if (this.datatable) {
            this.datatable.reset();
          }

          this.first = Number(localStorage.getItem("nm-pageno-" + this.title));

          if (localStorage.getItem("nm-limit-" + this.title)) {
            this.limit = Number(localStorage.getItem("nm-limit-" + this.title));
          }

          this.lastPrimeNGEvent = {};
          this.lastPrimeNGEvent.filters = {};
          this.sort = "";
          this.filter = [];

          if (this.lastUriLocalStorage.exists() && this.firstLoad) {
            let lasturi = this.lastUriLocalStorage.value;
            let timer = observableTimer(1);
            timer.subscribe((t) => {
              if (this.datatable) {
                this.restoreState(lasturi);
              } else {
                this.restoreStateForListview(lasturi);
              }
              this.firstLoad = false;
            });
          } else {
            this.reload();
          }
        }
      });

    observableCombineLatest(this.results, this.editAttributeLinkParameters)
      .pipe(takeUntil(this.unsubscribe))
      .subscribe(([data, parameters]) => {
        if (!this.editAttributeLinkParameters) {
          return;
        }
        this.editAttributeLinkParams = parameters;

        data.forEach((row, index) => {
          for (let key in row) {
            if (
              row[key].changeFieldValue &&
              row[key].changeFieldValue.fieldValue === row[key].source[0].value
            ) {
              this.setFieldValueAndDisable(
                data,
                row[key],
                row[key].changeFieldValue
              );
            }
          }
          if (row[this.editAttributeLinkParams.identifier]) {
            let newAttribute = deepCopy(
              data[index][this.editAttributeLinkParams.identifier]
            );
            newAttribute.linkParams = this.addLinkParamtersToAttribute(
              newAttribute.linkParams
            );
            this.updateAttribute(
              data,
              index,
              this.editAttributeLinkParams.identifier,
              newAttribute
            );
          }
        });

        this.editedRowsArray.next(this.getEditedRows(data));

        if (this.newRow) {
          for (let key in this.newRow) {
            if (
              this.newRow[key].changeFieldValue &&
              this.newRow[key].changeFieldValue.fieldValue ===
                this.newRow[key].source[0].value
            ) {
              this.setFieldValueAndDisable(
                null,
                this.newRow[key],
                this.newRow[key].changeFieldValue
              );
            }
          }
          if (this.newRow[this.editAttributeLinkParams.identifier]) {
            let newAttribute = deepCopy(
              this.newRow[this.editAttributeLinkParams.identifier]
            );
            newAttribute.linkParams = this.addLinkParamtersToAttribute(
              newAttribute.linkParams
            );
            this.updateAttribute(
              data,
              undefined,
              this.editAttributeLinkParams.identifier,
              newAttribute
            );
          }
        }
      });

    this.readOnlyMode
      .asObservable()
      .pipe(takeUntil(this.unsubscribe))
      .subscribe((readOnly) => {
        if (readOnly) {
          this.enableAdd = false;
          this.autoexpand = false;
          this.enableSaveRow = false;
        } else {
          this.enableAdd = true;
          this.autoexpand = true;

          if (this.configuration.configuration.enableSaveRow != false) {
            this.enableSaveRow = true;
          }
        }
      });

    this.onChange
      .pipe(
        debounceTime(this.debounceTime),
        map((trigger) => {
          let input = this.currentLink;
          let offset = this.offset || 0;
          let limit = this.limit || 10;
          let sort = this.sort || "";
          let filter = this.filter || [];
          if (!input) {
            return null;
          }
          let uriParams = Object.assign({});
          if (!this.clientPaging) {
            uriParams.offset = offset;
            uriParams.limit = limit;
            uriParams.sort = sort;
            uriParams.filter = filter;
          }
          if (
            this.selectedLocaleString &&
            this.selectedLocaleString.length > 0
          ) {
            uriParams["data-locale"] = this.selectedLocaleString;
          }

          if (
            this.selectedUiLocaleString &&
            this.selectedUiLocaleString.length > 0
          ) {
            uriParams.locale = this.selectedUiLocaleString;
          }

          if (trigger !== undefined) {
            uriParams.cache = (<Date>trigger).getTime();
            input += "{&cache}";
          }
          uriParams.template = input;
          return uriParams;
        }),
        map((uriParams) => {
          if (!uriParams) {
            return null;
          }
          this.template = uriTemplates((<any>uriParams).template);
          return this.template.fill(uriParams);
        }),
        switchMap((uri) => {
          this.requestRunning = true;
          if (this.requestStarted) {
            this.requestStarted = false;
            this._progressbarService.requestFinished();
          }
          this.searchLink.next(uri);
          //this._progressbarService.requestFinished();
          return observableOf(uri).pipe(
            withLatestFrom(this.showProgressBar),
            mergeMap(([uri, showProgressBar]) => {
              if (uri && !uri.startsWith("undefined")) {
                //this._progressbarService.addRequest();
                this.lastUriLocalStorage.value = uri;
                if (this.externalResource) {
                  return this.listService.getTemplatedFilteredResults(uri);
                } else {
                  this.requestStarted = true;
                  return this.listService.getTemplatedFilteredResults(
                    uri,
                    showProgressBar
                  );
                }
              } else {
                //this._progressbarService.requestFinished();
                return observableEmpty();
              }
            }),
            catchError((err) => {
              //this._progressbarService.requestFinished();
              this._notificationService.fromResponse(err);
              this.requestRunning = false;
              return observableEmpty();
            })
          );
        }),
        takeUntil(this.unsubscribe)
      )
      .subscribe(
        (data) => {
          if (this.returnListData) {
            this.dataOutputted = data;
            this.listDataLoaded.next();
          } else {
            this.dataOutputted = deepCopy(data);
            this.requestRunning = false;
            this.mapResult(data);
            this.dataRecieved = true;
            this.checkDisableStatus.next();
            //this._progressbarService.requestFinished();
          }
        },
        (err) => {
          console.log(err);
          this._progressbarService.requestFinished();
        }
      );

    this.cols
      .pipe(
        takeUntil(this.unsubscribe),
        map((cols) => {
          for (let col of cols) {
            if (!col.sortable && !col.filter) {
              if (col.style) {
                col.style += " noFilter";
              } else {
                col.style = "noFilter";
              }
            } else if (col.sortable && !col.filter) {
              if (col.style) {
                col.style += " sortOnly";
              } else {
                col.style = "sortOnly";
              }
            }
          }
          return cols;
        })
      )
      .subscribe((cols) => {
        let columns = {};
        for (let col of cols) {
          columns[col.field] = col;
        }

        this.columns = columns;
      });
  }

  private restoreState(lasturi) {
    console.log("restore state");
    let params;
    if (!this.template) {
      params = UtilService.getAllUrlParams(lasturi);
    } else {
      params = this.template.fromUri(lasturi);
    }

    if (params === undefined) {
      return;
    }
    if (params.filter !== undefined) {
      for (var item of params.filter) {
        let filterIdentifier = item.substring(0, item.indexOf(":"));
        let filter = item.substring(
          item.indexOf('"') + 1,
          item.lastIndexOf('"')
        );
        this.datatable.filter(filter, filterIdentifier, "startsWith");

        var filterItem = this.filterKey(filterIdentifier, filter);
        this.lastPrimeNGEvent.filters[filterIdentifier] = {};
        this.lastPrimeNGEvent.filters[filterIdentifier].value = filter;
        this.filter.push(filterItem);
      }
    }
    if (params.sort !== undefined) {
      let item = params.sort;
      let sortIdentifier = item.substring(0, item.indexOf(":"));
      let sortValue = item.substring(item.indexOf(":") + 1, item.length);
      this.datatable.sortField = sortIdentifier;
      this.datatable.sortOrder = sortValue === "asc" ? 1 : -1;
      this.datatable.sortSingle();
      this.lastPrimeNGEvent.sortOrder = sortValue === "asc" ? 1 : -1;
      this.lastPrimeNGEvent.sortField = sortIdentifier;
      this.sort = params.sort;
    }

    if (params.offset !== undefined && params.offset != 0) {
      this.offset = parseInt(params.offset);
      this.limit = parseInt(params.limit);
      let paging = {
        first: parseInt(params.offset),
        rows: parseInt(params.limit),
      };
    }
    this.datatable.first = this.first;

    this.reload();
  }

  private restoreStateForListview(lasturi) {
    this.lastPrimeNGEvent.filters = {};
    let params;

    if (!this.template) {
      params = UtilService.getAllUrlParams(lasturi);
    } else {
      params = this.template.fromUri(lasturi);
    }

    if (params === undefined) {
      return;
    }

    if (params.filter !== undefined) {
      for (var item of params.filter) {
        let filterIdentifier = item.substring(0, item.indexOf(":"));
        let filter = item.substring(
          item.indexOf('"') + 1,
          item.lastIndexOf('"')
        );
        var filterItem = this.filterKey(filterIdentifier, filter);
        this.lastPrimeNGEvent.filters[filterIdentifier] = {};
        this.lastPrimeNGEvent.filters[filterIdentifier].value = filter;
        this.filter.push(filterItem);
      }
    }

    if (params.sort !== undefined) {
      let item = params.sort;
      let sortIdentifier = item.substring(0, item.indexOf(":"));
      let sortValue = item.substring(item.indexOf(":") + 1, item.length);
      this.lastPrimeNGEvent.sortOrder = sortValue === "asc" ? 1 : -1;
      this.lastPrimeNGEvent.sortField = sortIdentifier;
      this.sort = params.sort;
    }

    this.keepSettingsAfterChangeViewMode = true;
    this.limit = this.limit || 10;
    this.offset = params.offset || 0;
    this.results.next([]);
    this.reload();
  }

  onKeyup($event) {
    if (this.clientPaging) {
      setTimeout(() => this.total.next(this.datatable._totalRecords), 300);
    }
  }

  onFilterKeyup(value, field) {
    this.lastPrimeNGEvent.filters[field] = {};
    this.lastPrimeNGEvent.filters[field].value = value;

    let duplicate = this.filter.filter((item) => item.startsWith(field));
    if (duplicate.length > 0) {
      this.filter.splice(this.filter.indexOf(duplicate[0]), 1);
    }

    this.filter.push(this.filterKey(field, value));
    this.results.next([]);
    this.limit = 10;
    this.offset = 0;
    this.filterChanged = true;
    this.reload();
  }

  getSortOrder(col) {
    if (this.lastPrimeNGEvent.sortField == col.field) {
      return this.lastPrimeNGEvent.sortOrder;
    }
  }

  onSortingChanged(event, col) {
    if (event.target.classList.contains("fa-sort-desc")) {
      event.target.classList.remove("fa-sort-desc");
      event.target.classList.add("fa-sort-asc");
      this.lastPrimeNGEvent.sortOrder = 1;
    } else if (event.target.classList.contains("fa-sort-asc")) {
      event.target.classList.remove("fa-sort-asc");
      event.target.classList.add("fa-sort-desc");

      this.lastPrimeNGEvent.sortOrder = -1;
    } else {
      event.target.classList.add("fa-sort-desc");
      this.lastPrimeNGEvent.sortOrder = -1;
    }

    this.lastPrimeNGEvent.sortField = col.field;
    this.keepSettingsAfterChangeViewMode = true;
    var order = this.lastPrimeNGEvent.sortOrder === 1 ? "asc" : "desc";
    this.sort = this.lastPrimeNGEvent.sortField.toString() + ":" + order;
    this.limit = 10;
    this.offset = 0;
    this.results.next([]);
    this.reload();
  }

  ngOnInit() {
    // this.datatable.expandedRows = [];
    this.lastPrimeNGEvent = {};
    this.lastPrimeNGEvent.filters = {};

    this._scrollService
      .getScrolledToBottomEvent()
      .pipe(
        distinctUntilChanged(),
        debounceTime(200),
        takeUntil(this.unsubscribe)
      )
      .subscribe((data) => {
        if (this._progressbarService.hasOpenRequests()) {
          return;
        }
        if (!this.isViewmodeList) {
          return;
        }
        let total = this.total.getValue();
        if (total < 10 || this.offset > total) {
          return;
        }
        this.offset = this.offset + 10;
        this.reload();
      });

    observableCombineLatest([this.results, this.updatedRowId.asObservable()])
      .pipe(takeUntil(this.unsubscribe))
      .subscribe(([data, rowId]) => {
        let updatedIndex = data.findIndex((row) => row.identifier === rowId);
        if (updatedIndex > -1) {
          data[updatedIndex]._actions = deepCopy(data[updatedIndex]._actions);
          this.editedRowsArray.next(this.getEditedRows(data));
        } else if (!this.addRowInvalid) {
          this.newRow = deepCopy(this.newRow);
          this.newRowObject.next(this.getNewRow(false));
        }
      });

    observableCombineLatest([
      this.results,
      this._editAttributeService.getAttributeChangedEvent(),
    ])
      .pipe(takeUntil(this.unsubscribe), debounceTime(0))
      .subscribe(([attributesData, attribute]) => {
        if (!attribute) {
          return;
        }
        this.editAttributeValueChanged.next(attribute);

        if (attribute.changeAttributeType) {
          this.setAttributeType(
            attributesData,
            attribute,
            attribute.changeAttributeType
          );
        } else if (attribute.changeAttributeLink) {
          this.setAttributeLinkParams(
            attributesData,
            attribute,
            attribute.changeAttributeLink
          );
        }

        if (attribute.changeFieldValue) {
          this.setFieldValueAndDisable(
            attributesData,
            attribute,
            attribute.changeFieldValue
          );
        }

        if (attribute.index != undefined) {
          this.editedRowsArray.next(this.getEditedRows(attributesData));
          this.invalidRowExists.next(
            !this.validateForm(attributesData[attribute.index])
          );
        } else {
          this.invalidRowExists.next(!this.validateForm(this.newRow, "new"));
          this.newRowObject.next(this.getNewRow(false));
        }
      });
  }

  setAttributeType(
    attributesData,
    attribute,
    changeAttributeType: ChangeAttributeType
  ) {
    let updateField = changeAttributeType.updateField;
    let attributeTypeOptions = changeAttributeType.optionAndType;
    let newAttributeType = this.attributesMap.get(
      attributeTypeOptions[attribute.source[0].value]
    );
    newAttributeType = newAttributeType
      ? deepCopy(newAttributeType)
      : deepCopy(this.attributesMap.get(updateField));

    this.updateAttribute(
      attributesData,
      attribute.index,
      updateField,
      newAttributeType
    );
  }

  setAttributeLinkParams(
    attributesData,
    attribute,
    changeAttributeLink: ChangeAttributeLink
  ) {
    let newAttribute = deepCopy(
      this.attributesMap.get(changeAttributeLink.updateField)
    );
    let params = this.editAttributeLinkParams
      ? deepCopy(this.editAttributeLinkParams)
      : {};
    params[changeAttributeLink.linkParameter] = attribute.source[0].value;
    newAttribute.linkParams = params;

    this.updateAttribute(
      attributesData,
      attribute.index,
      changeAttributeLink.updateField,
      newAttribute
    );
  }

  setFieldValueAndDisable(
    attributesData,
    attribute,
    changeFieldValue: ChangeFieldValue
  ) {
    let newAttribute;
    if (changeFieldValue.fieldValue === attribute.source[0].value) {
      newAttribute = deepCopy(
        this.attributesMap.get(changeFieldValue.updateField)
      );
      newAttribute.source[0].value = this.editAttributeLinkParams[
        changeFieldValue.updateValue
      ];
      if (changeFieldValue.disabled != null) {
        newAttribute["read-only"] = changeFieldValue.disabled;
      }
    } else {
      newAttribute =
        attribute.index == null
          ? deepCopy(this.newRow[changeFieldValue.updateField])
          : deepCopy(
              attributesData[attribute.index][changeFieldValue.updateField]
            );
      if (
        changeFieldValue.disabled != null &&
        newAttribute["read-only"] == changeFieldValue.disabled
      ) {
        newAttribute["read-only"] = !changeFieldValue.disabled;
      }
    }
    this.updateAttribute(
      attributesData,
      attribute.index,
      changeFieldValue.updateField,
      newAttribute
    );
  }

  updateAttribute(attributesData, index, updateField, newAttribute) {
    if (index != undefined) {
      newAttribute.index = index;
      attributesData[index][updateField] = newAttribute;
    } else {
      this.newRow[updateField] = newAttribute;
    }
  }

  ngOnDestroy(): void {
    this.unsubscribe.destroy();
    this._progressbarService.requestFinished();
  }

  onChangeViewMode(event) {
    this.totalresults = [];
    this.isViewmodeList = event.checked;
    localStorage.setItem(
      "nm-isViewmodeList",
      this.isViewmodeList === true ? "true" : "false"
    );
    this.keepSettingsAfterChangeViewMode = true;
    if (!this.isViewmodeList) {
      this.limit = 10;
      let timer = observableTimer(1);
      timer.subscribe((t) => {
        if (this.lastUriLocalStorage.value) {
          this.restoreState(this.lastUriLocalStorage.value);
        }
      });
    } else {
      this.results.next([]);
      this.limit = 10;
      this.offset = 0;
      this.reload();
    }
  }

  private filterKey(field: string, value: string) {
    let filterType = this.columns[field]["filter-type"]
      ? this.columns[field]["filter-type"]
      : "";
    return (
      field + ":" + (filterType ? `${filterType}:` : "") + '"' + value + '"'
    );
  }

  public loadData(event: LazyLoadEvent) {
    var _sort: string = "";
    var _filter: string[] = [];
    if (!this.isViewmodeList) {
      this.lastPrimeNGEvent = event;
    }
    if (typeof event.sortField !== "undefined" && event.sortField !== null) {
      var order = event.sortOrder === 1 ? "asc" : "desc";
      _sort = event.sortField.toString() + ":" + order;
    }
    if (typeof event.filters !== "undefined" && event.filters !== null) {
      for (let field in event.filters) {
        _filter.push(this.filterKey(field, event.filters[field].value));
      }
    }

    if (!this.keepSettingsAfterChangeViewMode) {
      this.sort = _sort;
      this.filter = _filter;
      this.offset = event.first;
      this.limit = event.rows;
    }

    this.keepSettingsAfterChangeViewMode = false;
    this.reload();
  }

  public reload(force: boolean = false) {
    if (force) {
      this.onChange.next(new Date());
    } else {
      this.onChange.next();
    }
  }

  private mapResult(data: ResultResource) {
    if (data["type"] === "ERROR" && data["message"].indexOf("T4") > 0) {
      this._notificationService.info(
        this.translateService.instant("title.max-size"),
        this.translateService.instant("message.max-size")
      );
      this.offset = 0;
      this.reload();
      if (this.datatable) {
        this.datatable.first = 0;
      }
    } else if (data["type"] === "ERROR" && data["message"].indexOf("T4") < 0) {
      this._notificationService.error(
        this.translateService.instant("title.error.action"),
        this.translateService.instant("imarket.api-call.error")
      );
    }
    if (data.total === 0 && !this.hideEmptyNotifitaion) {
      this._notificationService.info(
        this.translateService.instant("list.empty.title"),
        this.translateService.instant("list.empty.content")
      );
    }

    if (this.dropdownAttributes) {
      data._embedded[this.dataType] = this.updateAttributesData(
        deepCopy(data._embedded[this.dataType])
      );
      this._editAttributeService.setAttributeChangedEvent(null);
    }

    this.lookups = data["lookups"];
    this.multiselectaction.next(data._actions);

    if (data._embedded && data._embedded[this.dataType].length > 0) {
      if (this.isViewmodeList) {
        if (this.slidevalue > 3) {
          if (this.offset === 0) {
            this.offset += 10;
            this.reload();
          } else if (this.slidevalue > 4 && this.offset < 20) {
            this.offset += 10;
            this.reload();
          }
        }
        if (this.filterChanged) {
          this.results.next(data._embedded[this.dataType]);
          this.filterChanged = false;
        } else {
          if (this.totalresults.length === 0) {
            this.results.subscribe((data) => {
              this.totalresults = data;
            });
          }
          this.totalresults = this.totalresults.concat(
            data._embedded[this.dataType]
          );
          this.results.next(this.totalresults);
        }
      } else {
        this.totalresults = data._embedded[this.dataType];
        this.results.next(data._embedded[this.dataType]);
      }
    } else if (!this.isViewmodeList) {
      this.results.next([]);
    }
    this.total.next(data.total);
    if (this.clientPaging) {
      this.total.next(data._embedded[this.dataType].length);
    }
    if (this.refresh) {
      this.datatable.expandedRows = [];

      if (this.autoexpand) {
        for (let index = 0; index < this.totalresults.length; index++) {
          if (
            this.lasttotalresults.length > 0 &&
            this.lasttotalresults[index]
          ) {
            if (
              this.lasttotalresults[index]["status"] !==
              this.totalresults[index]["status"]
            ) {
              this.expandedRows.push(this.totalresults[index]);
            }
          }
        }

        if (this.totalresults[0]) {
          if (
            this.totalresults[0]["status"] === "COMPLETED" &&
            this.offset === 0 &&
            this.filter.length === 0
          ) {
            this.expandedRows.push(this.totalresults[0]);
          }
        }
      }
      for (const row of this.expandedRows) {
        let rowtoAdd = this.totalresults.filter(
          (item) => item.identifier === row.identifier
        );
        if (rowtoAdd.length > 0) {
          this.datatable.expandedRows.push(rowtoAdd[0]);
        }
      }
    }
    // TODO: This leads to lost parameters
    // this.currentLink = data._links["custom"].href;

    this.lasttotalresults = this.totalresults;

    if (this.enableAdd && this.autoexpand && this.datatable) {
      this.datatable.expandedRows = [];
      this.datatable.expandedRows.push(
        this.totalresults[this.totalresults.length - 1]
      );
      this.addNewRowAttributes();
    }
  }

  updateAttributesData(data: any): any {
    data.forEach((row, index) => {
      for (let key in row) {
        if (this.attributesMap.get(key)) {
          row[key].index = index;
          if (row[key].validation) {
            row[key].validation = this.setAttributeValidations(
              row[key].validation
            );
          }
        }
      }
      if (
        this.editAttributeLinkParams &&
        row[this.editAttributeLinkParams.identifier]
      ) {
        let newAttribute = row[this.editAttributeLinkParams.identifier];
        newAttribute.linkParams = this.addLinkParamtersToAttribute(
          newAttribute.linkParams
        );
      }
    });

    return data;
  }

  addNewRowAttributes() {
    this.newRow = {};
    this.addRowInvalid = true;

    if (this.addRowComment) {
      let action: Action = {
        type: "event",
        description: "click-add-comment",
        payload: {
          id: 0,
        },
        selectors: {
          iconClass: "--invisible",
        },
        title: null,
        href: null,
      };

      this.newRow._actions = {
        "add-comment": action,
      };
    }

    for (let key in this.columns) {
      let col = this.columns[key];
      if (col.fieldType === "editAttribute") {
        let attributeOption: any = {};
        if (this.attributesMap.get(col.field)) {
          attributeOption = deepCopy(this.attributesMap.get(col.field));
        }
        attributeOption.index = null;
        this.newRow[col.field] = attributeOption;
      }
    }
    if (
      this.editAttributeLinkParams &&
      this.newRow[this.editAttributeLinkParams.identifier]
    ) {
      let newAttribute = this.newRow[this.editAttributeLinkParams.identifier];
      newAttribute.linkParams = this.addLinkParamtersToAttribute(
        newAttribute.linkParams
      );
    }
  }

  addLinkParamtersToAttribute(conditionParams) {
    let outsideParams = deepCopy(this.editAttributeLinkParams);
    if (conditionParams) {
      for (let param in conditionParams) {
        if (!outsideParams.hasOwnProperty(param)) {
          outsideParams[param] = conditionParams[param];
        }
      }
    }
    if (outsideParams.externalParam) {
      delete outsideParams[outsideParams.externalParam];
      delete outsideParams.externalParam;
    }
    return outsideParams;
  }

  setAttributeValidations(attributeValidation) {
    let mappedValidations = {};
    attributeValidation.forEach((validation) => {
      let mappedParam = validation.parameter;
      if (!isNaN(parseInt(mappedParam))) {
        mappedParam = parseInt(mappedParam);
      } else if (validation.parameter === "true") {
        mappedParam = true;
      } else if (validation.parameter === "false") {
        mappedParam = false;
      }
      mappedValidations[validation.type] = mappedParam;
    });
    return mappedValidations;
  }

  onPage(event) {
    this.limit = event.rows;
    this.offset = event.first;
    localStorage.setItem("nm-pageno-" + this.title, this.offset.toString());
    localStorage.setItem("nm-limit-" + this.title, this.limit.toString());
  }

  showDetails(path, appendToPath?) {
    let navigate = true;
    for (let index in path) {
      if (path[index]) {
        path[index] = encodeURIComponent(path[index]);
      } else {
        navigate = false;
        appendToPath = false;
        this._notificationService.error(
          this.translateService.instant(this.badLinkNotificationTitle),
          this.translateService.instant(this.badLinkNotificationMessage)
        );
        break;
      }
    }
    if (navigate && !appendToPath) {
      this.router.navigate(path, { relativeTo: this.route });
    } else if (appendToPath) {
      this.sendIdentifier(path);
    }
  }

  onSelect(event) {}

  keydown(event: any) {
    if (event.keyCode === 16) {
      this.shiftIsPressed = true;
      this.selectedRowsOnShift = this.selectedRows;
    }
  }

  keyup(event: any) {
    if (event.keyCode === 16) {
      this.shiftIsPressed = false;
    }
  }

  onRowSelectChange(event) {
    this.selectedItems.next(this.selectedRows);
    let selectedRowsOnShiftIndexes = [];
    let selectedRowsIndex;
    let selectedRowsOnShiftIndexesMin;
    let selectedRowsOnShiftIndexesMax;
    let fromIndex;
    let toIndex;

    if (this.shiftIsPressed) {
      this.results.subscribe((allrows) => {
        allrows.forEach((row, index) => {
          this.selectedRowsOnShift.forEach((selectedRow, selectedRowindex) => {
            if (row.identifier === selectedRow.identifier) {
              selectedRowsOnShiftIndexes.push(index);
            }
          });
          if (row.identifier === this.selectedRows[0].identifier) {
            selectedRowsIndex = index;
          }
        });

        selectedRowsOnShiftIndexesMin = Math.min.apply(
          Math,
          selectedRowsOnShiftIndexes
        );
        selectedRowsOnShiftIndexesMax = Math.max.apply(
          Math,
          selectedRowsOnShiftIndexes
        );

        if (selectedRowsIndex < selectedRowsOnShiftIndexesMin) {
          fromIndex = selectedRowsIndex;
          toIndex = selectedRowsOnShiftIndexesMax;
        } else if (selectedRowsIndex > selectedRowsOnShiftIndexesMax) {
          fromIndex = selectedRowsOnShiftIndexesMin;
          toIndex = selectedRowsIndex;
        }

        allrows.forEach((row, index) => {
          if (fromIndex <= index && toIndex >= index) {
            this.selectedRows.push(row);
            this.selectedItems.next(this.selectedRows);
          }
        });
      });
    }

    if (this.selectedRows.length > 1) {
      this.isMultiselectActionNeeded = true;
    }
    let payload = [];
    this.selectedRows.forEach((row) => {
      payload.push(row.identifier);
    });
    this.multiselectpayload.next(payload);
  }

  toogleContentVisibility() {
    this.contentVisible = !this.contentVisible;
  }

  public slideChange(event) {
    if (this.slidevalue == 1) {
      this.boxWidth = "100%";
      this.boxHeight = "600px";
    } else if (this.slidevalue == 2) {
      this.boxWidth = "50%";
      this.boxHeight = "350px";
    } else if (this.slidevalue == 3) {
      this.boxWidth = "33%";
      this.boxHeight = "220px";
    } else if (this.slidevalue == 4) {
      this.boxWidth = "25%";
      this.boxHeight = "190px";
    } else if (this.slidevalue == 5) {
      this.boxWidth = "20%";
      this.boxHeight = "130px";
    }

    if (this.slidevalue > 3 && !this.requestRunning) {
      if (this.offset === 0) {
        this.offset += 10;
        this.reload();
      } else if (this.slidevalue === 5 && this.offset === 10) {
        this.offset += 10;
        this.reload();
      }
    }
  }

  private mapField(value: any, type: string): any {
    switch (type) {
      case "date":
        return value.substring(0, 10);
      case "datetime":
        const date = new Date(value);
        return date.toLocaleDateString(
          this.selectedLocaleString,
          this.dateOptions
        );
      default:
        return value;
    }
  }

  onEnter(event) {
    event.target.blur();
  }

  saveNewRow() {
    let updatedRow = this.getNewRow(true);
    this.addRowInvalid = true;
    this.addNewRow.next(updatedRow);
  }

  getNewRow(saveRow: boolean) {
    let updatedRow = {};
    for (let key in this.newRow) {
      if (this.newRow.hasOwnProperty(key)) {
        let property = this.newRow[key];
        if (property && property.hasOwnProperty("source")) {
          updatedRow[key] = deepCopy(property.source[0].value);
          if (saveRow) {
            this.newRow[key] = deepCopy(property);
            this.newRow.source = [{ value: "" }];
          }
        } else {
          updatedRow[key] = this.newRow[key]
            ? deepCopy(this.newRow[key])
            : null;
          if (saveRow && key != "_actions") {
            this.newRow[key] = "";
          }
        }
      }
    }
    return updatedRow;
  }

  getEditedRows(editedRows: any) {
    let updatedRows: any = [];
    editedRows.forEach((editedRow) => {
      let updatedRow = this.formatEditAttribute(editedRow);
      updatedRows.push(updatedRow);
    });
    return updatedRows;
  }

  getUrlVariables(mainUri: string, occurance: number) {
    let Length = mainUri.length,
      i = -1;
    while (occurance-- && i++ < Length) {
      i = mainUri.indexOf("/", i);
      if (i < 0) break;
    }
    return mainUri.slice(i + 1, mainUri.indexOf("?")).split("/");
  }

  sendIdentifier(identifier) {
    this.rowIdentifier.next(identifier);
  }

  searchRuleId(productNo, channelId) {
    this.router.navigate([
      "/product-search/product/" + productNo + "/" + channelId,
    ]);
  }

  downloadTable() {}

  validateForm(row, type?) {
    let valid = true;
    for (let key in row) {
      if (
        (row[key] &&
          row[key].hasOwnProperty("source") &&
          (row[key].source[0].value === "" ||
            row[key].source[0].value == null) &&
          (!row[key].validation ||
            (row[key].validation && row[key].validation.IS_MANDATORY))) ||
        (key != "_actions" && key != "source" && row[key] == "")
      ) {
        valid = false;
        break;
      }
    }
    if (type === "new") {
      this.addRowInvalid = !valid;
    }
    return valid;
  }

  showNames(result: any[]): string {
    return result
      .map((names) => {
        if (names.name) {
          return names.name;
        } else {
          return names;
        }
      })
      .join(", ");
  }

  customSort(event, type) {
    switch (type) {
      case "itemStatus": {
        let order: any[] = [
          "open",
          "shipped",
          "returned",
          "partially_shipped",
          "cancelled",
        ];
        this.datatable.value = this.datatable.value.sort((a, b) => {
          if (order.indexOf(a["itemStatus"]) > order.indexOf(b["itemStatus"])) {
            return 1;
          }
          if (order.indexOf(a["itemStatus"]) < order.indexOf(b["itemStatus"])) {
            return -1;
          }
          return 0;
        });

        if (event.order === -1) {
          this.datatable.value.reverse();
        }
      }
      case "itemPrice": {
        this.datatable.value = this.datatable.value.sort((a, b) => {
          if (a["itemPrice"]["amount"] > b["itemPrice"]["amount"]) {
            return 1;
          }
          if (a["itemPrice"]["amount"] < b["itemPrice"]["amount"]) {
            return -1;
          }
          return 0;
        });
        if (event.order === -1) {
          this.datatable.value.reverse();
        }
      }
    }
  }

  getFormattedDate(date: string) {
    let ch = this.selectedUiLocaleString === "en-GB" ? "/" : ".";
    var splitted = date.split(ch, 3);
    let formattedDate =
      splitted[2] +
      "-" +
      (splitted[1].length === 1 ? "0" + splitted[1] : splitted[1]) +
      "-" +
      (splitted[0].length === 1 ? "0" + splitted[0] : splitted[0]) +
      "T00:00:00.000Z";
    return formattedDate;
  }

  setDateValue(date: string) {
    return new Date(date);
  }

  onFilterHeaderFocus(event) {
    if (
      event.querySelector("label").offsetWidth <
      event.querySelector("label").scrollWidth
    ) {
      this.disableHeaderTooltip = false;
    } else {
      this.disableHeaderTooltip = true;
    }
  }

  onHeaderFocus(event) {
    if (event.offsetWidth < event.scrollWidth) {
      this.disableHeaderTooltip = false;
    } else {
      this.disableHeaderTooltip = true;
    }
  }

  checkTableHeight(visible) {
    if (visible) {
      this.checkDisableStatus.next();
    }
  }

  initializeAttributesMap(attributesLink) {
    this.listService
      .getAttributeValues(attributesLink)
      .subscribe((attributes) => {
        let attributesData = jQuery.extend(true, [], attributes);
        for (let attributeIdentifier in attributesData) {
          if (attributesData[attributeIdentifier].validation) {
            attributesData[
              attributeIdentifier
            ].validation = this.setAttributeValidations(
              attributesData[attributeIdentifier].validation
            );
          }
          this.attributesMap.set(
            attributeIdentifier,
            attributesData[attributeIdentifier]
          );
        }
      });
  }

  sendEditedRow(row, type) {
    let updatedRow = this.formatEditAttribute(row);
    if (type === "edit") {
      this.onEdit.next(updatedRow);
    } else {
      this.rowPreview.next(updatedRow);
    }
  }

  formatEditAttribute(row: any) {
    let updatedRow = {};
    for (let key in row) {
      if (row[key]) {
        updatedRow[key] = row[key].hasOwnProperty("source")
          ? deepCopy(row[key].source[0].value)
          : deepCopy(row[key]);
      }
    }
    return updatedRow;
  }

  checkAttributeValidation(attribute: any) {
    return (
      attribute.validation.MAX_LENGTH &&
      attribute.source[0].value.length === attribute.validation.MAX_LENGTH
    );
  }

  decodeFilterNameSpecialCharacters(value) {
    return decodeURIComponent(value);
  }
}