/********************************************************************************
 * Copyright (c) 2015, 2023 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 ********************************************************************************/

import { DatePipe } from "@angular/common";
import { Component, OnDestroy, OnInit } from "@angular/core";
import { ActivatedRoute } from "@angular/router";
import { TRANSLATE } from "@core/mdm-core.module";
import { MDMItem } from "@core/mdm-item";
import { MDMNotificationService } from "@core/mdm-notification.service";
import { SystemParameterService } from "@details/services/systemparameter.service";
import { FileLinkContextWrapper } from "@file-explorer/model/file-explorer.model";
import { ContextFilesService } from "@file-explorer/services/context-files.service";
import { FileService } from "@file-explorer/services/file.service";
import { NavigatorService } from "@navigator/navigator.service";
import { Attribute, ContextGroup, Node } from "@navigator/node";
import { TranslateService } from "@ngx-translate/core";
import { TreeNode } from "primeng/api";
import { TreeTable } from "primeng/treetable";
import { of, Subscription } from "rxjs";
import { catchError, finalize, skip, take, tap } from "rxjs/operators";
import { Role } from "src/app/authentication/authentication.service";
import { EntityCreatorService } from "src/app/entity-creator/entity-creator.service";
import { MDMEntity } from "src/app/entity-creator/model/mdm-entity";
import { TimezoneService } from "src/app/timezone/timezone-service";
import { AuthenticationService } from "../../../authentication/authentication.service";
import { Components, Context, ContextAttributeIdentifier, Sensor } from "../../model/details.model";
import { ContextService } from "../../services/context.service";

@Component({
  selector: "mdm-detail-context",
  templateUrl: "mdm-detail-descriptive-data.component.html",
  styleUrls: ["mdm-detail-descriptive-data.component.css"],
})
export class MDMDescriptiveDataComponent implements OnInit, OnDestroy {
  private readonly StatusLoading = TRANSLATE("details.mdm-detail-descriptive-data.status-loading");
  private readonly StatusSaving = TRANSLATE("details.mdm-detail-descriptive-data.status-saving");
  private readonly StatusNoNodes = TRANSLATE("details.mdm-detail-descriptive-data.status-no-nodes-available");
  private readonly StatusVirtualNodes = TRANSLATE("details.mdm-detail-descriptive-data.status-virtual-node-selected");
  private readonly StatusNoDescriptiveData = TRANSLATE("details.mdm-detail-descriptive-data.status-no-descriptive-data-available");

  public treeNodes: { [key: string]: TreeNode[] };

  // this holds the type dependant original context data in case of cancelling the edit mode
  private tmpTreeNodes: Node[];

  public selectedNode: Node;
  public contextType: string;

  public contextComponents: Components;
  public sensors: Sensor[];
  public status: string;

  // reference to be able to use enum in html template
  public contextGroupEnum = ContextGroup;

  public editMode: boolean;

  public isTreeTableExpanded = true;

  private sub = new Subscription();

  public tplComponents: MDMEntity[];
  public selectedTplComponent: MDMEntity[] = [];
  public showTplComponents = false;
  public selectedContext: string[] = [];
  public showConfirmDelete = false;
  public selectedContextComponentName: string;
  ctxCompName = { ctxName: "" };
  hasOrdered: boolean;
  hasMeasured: boolean;

  constructor(
    private route: ActivatedRoute,
    private _contextService: ContextService,
    private navigatorService: NavigatorService,
    private notificationService: MDMNotificationService,
    private translateService: TranslateService,
    private datePipe: DatePipe,
    private authenticationService: AuthenticationService,
    private fileService: FileService,
    private contextFileService: ContextFilesService,
    private systemParameterService: SystemParameterService,
    private entityCreatorService: EntityCreatorService,
    private timezoneService: TimezoneService,
  ) {}

  public canEdit: boolean;
  public isTest: boolean;

  public canEdit4Env: boolean;
  private editAllowed: { [key: string]: boolean } = {};

  ngOnInit() {
    this.authenticationService.isUserInRole([Role.Admin.toString(), Role.User.toString()]).subscribe((b) => (this.canEdit = b));
    this.status = this.StatusNoNodes;
    this.editMode = false;

    this.timezoneService.timezoneChanged.subscribe(() => {
      this.reloadData();
    });

    this.sub.add(
      this.route.params.subscribe(
        (params) => this.refreshContextData(params["context"]),
        (error) =>
          this.notificationService.notifyError(
            this.translateService.instant("details.mdm-detail-descriptive-data.err-cannot-load-scope"),
            error,
          ),
      ),
    );
    // node changed from the navigation tree
    this.sub.add(
      this.navigatorService
        .onSelectionChanged()
        .pipe(
          skip(1), // skip first to avoid double loading, since path param also changes for sure on init.
          tap((obj) => this.handleSelectionChanged(obj)),
          finalize(() => (this.status = this.StatusNoDescriptiveData)),
          catchError((error) =>
            of(
              this.notificationService.notifyError(
                this.translateService.instant("details.mdm-detail-descriptive-data.err-cannot-load-data"),
                error,
              ),
            ),
          ),
        )
        .subscribe(),
    );

    // file changed
    this.fileService.onFileChanged().subscribe((link) => this.handleFileChanged(link));
  }

  ngOnDestroy() {
    this.sub.unsubscribe();
  }

  private handleSelectionChanged(obj: Node | MDMItem) {
    this.isTest = false;
    if (obj instanceof MDMItem) {
      this.selectedNode = undefined;
      this.status = this.StatusVirtualNodes;
    } else {
      this.refreshDetailData(obj);
      this.handleEditMode(obj);
    }
  }

  handleFileChanged(fileLinkContextWrapper: FileLinkContextWrapper) {
    if (this.treeNodes != undefined) {
      this.treeNodes[fileLinkContextWrapper.contextType]
        .filter((tnode) => tnode.label === fileLinkContextWrapper.contextComponent.name)
        .map((tnode) => tnode.children)
        .reduce((a, b) => a.concat(b), [])
        .filter((tnode) => tnode.data.attribute.name === fileLinkContextWrapper.attribute.name)
        .forEach((tnode) => (tnode.data.attribute = fileLinkContextWrapper.attribute));
      // spread is necessary for treeTable changeDetection
      this.treeNodes[fileLinkContextWrapper.contextType] = [...this.treeNodes[fileLinkContextWrapper.contextType]];
    }
  }

  setContext(context: string) {
    switch (context) {
      case "uut":
        this.contextType = "UNITUNDERTEST";
        break;
      case "te":
        this.contextType = "TESTEQUIPMENT";
        break;
      case "ts":
        this.contextType = "TESTSEQUENCE";
        break;
    }
  }

  /**
   * Listener method to change the context tab
   *
   * @param contextType
   */
  refreshContextData(contextType: string) {
    // revert before changing the context
    this.reloadData();
    this.setContext(contextType);
    this.editMode = false;
  }

  private reloadData() {
    this.sub.add(
      this.navigatorService
        .onSelectionChanged()
        .pipe(
          take(1),
          tap((object) => this.handleSelectionChanged(object)),
        )
        .subscribe(),
    );
  }

  /**
   * Listener method to change the node
   *
   * @param node
   */
  refreshDetailData(node: Node) {
    this.status = this.StatusLoading;
    if (node != undefined) {
      this.selectedNode = node;
      this.editMode = false;
      this.contextComponents = undefined;
      this.treeNodes = undefined;
      if (node.type.toLowerCase() === "measurement" || node.type.toLowerCase() === "teststep" || node.type.toLowerCase() === "test") {
        this.loadContext(node);
      } else {
        this.status = this.StatusNoDescriptiveData;
      }
      if (node.type.toLowerCase() === "test") {
        this.isTest = true;
      }
    }
  }

  /**
   * Load the context data for the provided node
   *
   * @param node
   */
  private loadContext(node: Node) {
    this._contextService.getContext(node).subscribe((components) => this.setComponents(components));
  }

  getContextAttribute(
    contextDescribable: Node,
    contextComponent: Node,
    attribute: Attribute,
    contextGroup?: ContextGroup,
    contextType?: string,
  ) {
    return new ContextAttributeIdentifier(contextDescribable, contextComponent, attribute, contextGroup, contextType);
  }

  getNodeClass(item: Node) {
    return "icon " + item.type.toLowerCase();
  }

  /**
   * Change the tree state to expanded or collapsed
   *
   * @param type
   * @param expand
   */
  toggleTreeNodeState(tt: TreeTable) {
    this.isTreeTableExpanded = !this.isTreeTableExpanded;
    const nodeArray = this.treeNodes[this.contextType];
    if (nodeArray != undefined) {
      for (const node of nodeArray) {
        this.recursiveChangeNodes(node, this.isTreeTableExpanded);
      }
    }

    // invoke table update when pressing the plus or minus buttons from the table header
    tt.updateSerializedValue();
    tt.tableService.onUIUpdate(tt.value);
  }

  /**
   * Change the tree node state recursively
   *
   * @param node
   * @param expand
   */
  recursiveChangeNodes(node: TreeNode, expand: boolean) {
    node.expanded = expand;
    if (node.children != undefined && node.children.length > 0) {
      for (const child of node.children) {
        this.recursiveChangeNodes(child, expand);
      }
    }
  }

  /**
   * Get the nodes from the current context
   *
   * @param nodes
   * @param parentId optional parent id which will get the child nodes
   */
  getNodes(nodes: Node[], parentId: string) {
    return nodes.filter((n) => this.nodeIsInCurrentContext(n, parentId));
  }

  nodeIsInCurrentContext(node: Node, parentId: string) {
    const parentNodeId = node.relations != null && node.relations.length > 0 ? node.relations[0].parentId : null;
    return (parentId === null && parentNodeId === null) || (parentId != null && parentNodeId != null && parentId === parentNodeId);
  }

  /**
   * Create a tree node based on the mdm entity
   *
   * @param node
   * @param context
   */
  createTreeNode(node: Node, children: Node[], contextType: string) {
    const data = {
      name: node.name,
      // 'attribute': node,
      header: true,
      mimeType: this.extractMimeType(node),
      optional: node.optional,
      id: node.id,
    };
    return <TreeNode>{
      label: node.name,
      data: data,
      children: this.createTreeChildren(node, children, data, contextType),
      icon: this.getNodeClass(node),
      expanded: true,
      optional: node.optional,
      defaultActive: node.defaultActive,
      testStepSeriesVariable: node.testStepSeriesVariable,
    };
  }

  /**
   * Create the tree children nodes recursive based on the mdm attributes and subsequent mdm entities
   *
   * @param node the current node
   * @param contexts the complete contexts
   */
  createTreeChildren(node: Node, children: Node[], parentData: any, contextType: string) {
    const list = node.attributes
      .filter((attr) => attr.name !== "MimeType" && attr.name !== "Name" && attr.name !== "Sortindex")
      .map((attribute) => {
        const patchedAttribute = this.patchAttribute(node, attribute, contextType);
        return {
          data: {
            name: attribute.name,
            attribute: patchedAttribute,
            header: false,
            mimeType: this.extractMimeType(node),
            orderedContextAttribute: this.getContextAttribute(
              parentData,
              this.selectedNode,
              patchedAttribute,
              ContextGroup.ORDERED,
              contextType,
            ),
            measuredContextAttribute: this.getContextAttribute(
              parentData,
              this.selectedNode,
              patchedAttribute,
              ContextGroup.MEASURED,
              contextType,
            ),
          },
          expanded: true,
        } as TreeNode;
      });

    const tplCompRel = node.relations.find((r) => r.entityType === "TemplateComponent");
    if (tplCompRel && tplCompRel.ids.length > 0) {
      const nodes = this.getNodesWithTplCompId(children, tplCompRel.ids[0]);
      for (const n of nodes) {
        list.push(this.createTreeNode(n, children, contextType));
      }
    }

    return list;
  }

  /**
   * Searches for nodes which have a relation to the given TemplateComponent ID.
   * @param nodes List with nodes to search
   * @param tplCompId  TemplateComponent ID
   */
  getNodesWithTplCompId(nodes: Node[], tplCompId: string) {
    return nodes.filter((n) => n.relations[0].parentId === tplCompId);
  }

  private extractMimeType(node: Node) {
    if (node != undefined) {
      const attr = node.attributes.find((attr) => attr.name === "MimeType");
      if (attr) {
        if (typeof attr.value === "string") {
          return attr.value;
        } else if (Array.isArray(attr.value) && attr.value.length === 1 && typeof attr.value[0] === "string") {
          return attr.value[0];
        } else if (Array.isArray(attr.value) && attr.value.length > 1 && typeof attr.value[1] === "string") {
          return attr.value[1];
        }
      }
    }
  }

  /**
   * Method to create a tree structure from the flat context entity and attribute map
   *
   * @param components
   */
  mapComponents(components: Components) {
    const list: { [key: string]: TreeNode[] } = {};
    if (components != undefined) {
      for (const key of Object.keys(components)) {
        const nodes: Node[] = this.getNodes(components[key], null);
        if (nodes != undefined) {
          list[key] = nodes.map((node) => this.createTreeNode(node, components[key], key));
        }
      }
    }
    return list;
  }

  /**
   * Convert, complement or load attribute values
   *
   * @param attribute
   */
  patchAttribute(node: Node, attribute: Attribute, contextType: string) {
    if (attribute.dataType != null && attribute.dataType.length > 0) {
      const val = attribute.value as any[];
      if ("FILE_RELATION" === attribute.dataType) {
        if (val.length > 0) {
          this.contextFileService
            .getMDMFileExts(this.getContextAttribute(node, this.selectedNode, attribute, ContextGroup.ORDERED, contextType))
            .subscribe((mdmLinks) => (val[0] = mdmLinks));
        }
        if (val.length > 1) {
          this.contextFileService
            .getMDMFileExts(this.getContextAttribute(node, this.selectedNode, attribute, ContextGroup.MEASURED, contextType))
            .subscribe((mdmLinks) => (val[1] = mdmLinks));
        }
      }
    }

    return attribute;
  }

  /** *********************
   * Edit functions start
   ********************** */

  convertFixedDateStr(dt: string, convertForUI: boolean) {
    let newDt = dt;
    let sourceFormat = "";

    /**
     * Get the translation immediately
     */
    sourceFormat = this.translateService.instant("details.mdm-detail-descriptive-data.transform-dateformat");

    if (dt != null && dt.length > 0 && convertForUI && dt.indexOf("T") > -1) {
      // for display purpose
      const tmpDt = this.parseISOString(dt);
      newDt = this.datePipe.transform(tmpDt, sourceFormat, "+0000");
    } else if (dt != null && dt.length > 0 && !convertForUI && dt.indexOf("T") === -1) {
      // re-convert UI date to server date for persistence
      if (newDt.indexOf("-") === -1) {
        // find the date patterns dd, MM and yyyy and grab the according index positions
        const startDay = sourceFormat.indexOf("d");
        const endDay = sourceFormat.lastIndexOf("d");
        const startMonth = sourceFormat.indexOf("M");
        const endMonth = sourceFormat.lastIndexOf("M");
        const startYear = sourceFormat.indexOf("y");
        const endYear = sourceFormat.lastIndexOf("y");
        // manually attach the time as toISOString() will not properly transform the winter/summer time
        newDt =
          dt.substring(startYear, endYear + 1) + "-" + dt.substring(startMonth, endMonth + 1) + "-" + dt.substring(startDay, endDay + 1);
        if (dt.indexOf(" ") > -1) {
          // use the provided timestamp
          newDt = newDt + "T" + dt.substring(dt.indexOf(" ") + 1) + ":00Z";
        } else {
          newDt = newDt + "T00:00:00Z";
        }
        if (newDt.length !== 20) {
          newDt = "";
        }
      }
    }
    return newDt;
  }

  /**
   * Fixed parsing for ISO date string
   *
   * @param s
   */
  parseISOString(s: string) {
    const b: any[] = s.split(/\D+/);
    return new Date(Date.UTC(b[0], --b[1], b[2], b[3], b[4], b[5], b[6]));
  }

  /**
   * Send the changed data to the backend
   *
   * @param node
   * @param type
   */
  private putContext(node: Node, type: string) {
    if (type === null) {
      return;
    }
    this.status = this.StatusSaving;
    this.treeNodes = undefined;

    const data = new Context();
    data.ordered = new Components();
    data.ordered[type] = this.getNodesWithUpdatedContent(this.contextComponents[type] as Node[], true);

    data.measured = new Components();
    data.measured[type] = this.getNodesWithUpdatedContent(this.contextComponents[type] as Node[], false);

    if (data.ordered[type].length === 0 && data.measured[type].length === 0) {
      this.treeNodes = this.mapComponents(this.contextComponents);
      return;
    }

    // clear for status display
    this.contextComponents = undefined;

    this._contextService.putContext(node, data).subscribe(
      (components) => {
        this.setComponents(components);
      },
      (error) =>
        this.notificationService.notifyError(
          this.translateService.instant("details.mdm-detail-descriptive-data.err-cannot-load-context"),
          error,
        ),
    );
  }

  onEdit(event: Event) {
    event.stopPropagation();
    this.editMode = true;
    this.tmpTreeNodes = JSON.parse(JSON.stringify(this.contextComponents[this.contextType]));
  }

  onCancelEdit(event: Event) {
    event.stopPropagation();
    this.editMode = false;
    this.isTreeTableExpanded = true;
    this.reloadData();
  }

  onSaveChanges(event: Event) {
    event.stopPropagation();
    this.editMode = false;
    this.isTreeTableExpanded = true;
    this.putContext(this.selectedNode, this.contextType);
    this.tmpTreeNodes = undefined;
  }

  onAddTempComponent(event: Event) {
    event.stopPropagation();
    this.entityCreatorService.getTemplateTestStep(this.selectedNode).subscribe((r) => {
      if (r.length > 0 && r[0].relations.filter((rel) => rel.contextType === this.contextType).length > 0) {
        this.entityCreatorService.getTemplateComponents(r[0], this.contextType).subscribe((co) => {
          this.setTplComponents(co);
          this.showTplComponents = true;
        });
      } else {
        this.notificationService.notifyInfo(
          this.translateService.instant("details.mdm-detail-descriptive-data.info-no-tempComp"),
          this.translateService.instant("details.mdm-detail-descriptive-data.msg-no_tplComp"),
        );
      }
    });
  }

  setTplComponents(entities: MDMEntity[]) {
    if (entities !== undefined) {
      let cIds: string[] = [];
      this.contextComponents[this.contextType].forEach((attr) => {
        if (attr.attributes[0].value.length === 2 && attr.attributes[0].value[0] !== undefined) {
          attr.relations.forEach((rel) => {
            if (rel.contextType === this.contextType) {
              cIds = cIds.concat(rel.ids);
            }
          });
        }
      });
      this.tplComponents = [];
      entities
        .filter(
          (ent) =>
            cIds.filter((id) => id === ent.id)[0] === undefined &&
            ent.attributes.filter((attr) => attr.name === "Optional" && attr.value === "true"),
        )
        .forEach((entity) => this.tplComponents.push(entity));
    }
  }

  onSaveSelection(event: Event) {
    event.stopPropagation();
    const compNames: string[] = [];
    this.selectedTplComponent.forEach((ent) => compNames.push(ent.name));
    this._contextService
      .addNewComponent(this.selectedNode.sourceName, this.contextType, this.selectedNode.id, compNames, this.selectedContext)
      .subscribe((components) => this.setComponents(components));
    this.selectedTplComponent = [];
    this.showTplComponents = false;
  }

  onDeleteComponent(event: Event, name: string) {
    event.stopPropagation();
    this.hasOrdered = this.contextComponents[this.contextType].filter((cmp) => cmp.name === name)[0].attributes[0].value[0] !== undefined;
    this.hasMeasured = this.contextComponents[this.contextType].filter((cmp) => cmp.name === name)[0].attributes[0].value.length === 2;
    this.selectedContext = [];
    this.selectedContextComponentName = name;
    this.ctxCompName = { ctxName: name };
    this.showConfirmDelete = true;
  }

  onNotDeleteSelection(event: Event) {
    event.stopPropagation();
    this.showConfirmDelete = false;
  }

  onDeleteSelection(event: Event) {
    if (this.selectedContext?.length > 0) {
      event.stopPropagation();
      this._contextService
        .deleteComponent(
          this.selectedNode.sourceName,
          this.contextType,
          this.selectedNode.id,
          this.selectedContextComponentName,
          this.selectedContext,
        )
        .subscribe((components) => this.loadContext(this.selectedNode));
      this.showConfirmDelete = false;
    }
  }

  private setComponents(components: Components) {
    if (components["UNITUNDERTEST"] != undefined || components["TESTEQUIPMENT"] != undefined || components["TESTSEQUENCE"] != undefined) {
      this.contextComponents = components;
      this.treeNodes = this.mapComponents(components);
    } else {
      this.status = this.StatusNoDescriptiveData;
    }
  }
  /**
   * Get the updated nodes from the current context
   *
   * @param contextComponents
   * @param type the context type
   * @param ordered true if ordered data, false if measured data
   */
  getNodesWithUpdatedContent(contextComponents: Node[], ordered: boolean) {
    const list = [];
    for (const component of contextComponents) {
      const attrs = [];
      for (const cAttribute of component.attributes) {
        const attr = new Attribute();
        let addAttr = true;
        attr.dataType = cAttribute.dataType;
        attr.name = cAttribute.name;
        attr.unit = cAttribute.unit;
        attr.value = "";

        if (ordered && cAttribute.value instanceof Array && cAttribute.value.length > 0) {
          attr.value = cAttribute.value[0];
        } else if (!ordered && cAttribute.value instanceof Array && cAttribute.value.length > 1) {
          attr.value = cAttribute.value[1];
        }
        // lookup new value from treenodes
        if (attr.dataType === "BOOLEAN" && attr.value != null && attr.value.toString().length > 0) {
          attr.value = attr.value.toString() === "true" ? "1" : "0";
        }

        // FILE_LINK_SEQUENCE is saved separately
        if (attr.dataType === "FILE_LINK_SEQUENCE" || attr.dataType === "FILE_LINK" || attr.dataType === "FILE_RELATION") {
          addAttr = false;
        }

        if (addAttr) {
          if (this.isAttributeValueModified(attr, component, ordered)) {
            attrs.push(attr);
          }
        }
      }
      // un-merged list
      if (attrs.length > 0) {
        const c = JSON.parse(JSON.stringify(component));
        c.attributes = attrs;
        list.push(c);
      }
    }
    return list;
  }

  private isAttributeValueModified(attr: Attribute, component: Node, ordered: boolean) {
    for (const tmpNode of this.tmpTreeNodes) {
      if (tmpNode.name === component.name) {
        for (const attribute of tmpNode.attributes) {
          if (attribute.name === attr.name && attribute.value instanceof Array) {
            const orgValue = ordered ? attribute.value[0] : attribute.value.length > 1 ? attribute.value[1] : undefined;
            if (orgValue != undefined) {
              if (attr.dataType === "BOOLEAN") {
                // server value = true or false, UI value = 1 or 0
                return (
                  (attr.value === "0" && orgValue === "true") ||
                  (attr.value === "1" && orgValue === "false") ||
                  (attr.value !== "" && orgValue === "")
                );
              } else {
                // plain comparison
                return attr.value !== orgValue;
              }
            }
            return false;
          }
        }
      }
    }
  }

  /** *********************
   * Edit functions end
   ********************** */

  handleEditMode(node: Node) {
    if (node != undefined) {
      if (this.editAllowed[node.sourceName] != undefined) {
        this.canEdit4Env = this.canEdit && this.editAllowed[node.sourceName];
      } else {
        this.systemParameterService.findSystemParameter(node.sourceName, "org.eclipse.mdm.detailview.editable").subscribe((values) => {
          if (values.length === 1) {
            this.editAllowed[node.sourceName] = values[0].attributes.find((attr) => attr.name === "Value").value === "false" ? false : true;
          } else {
            this.editAllowed[node.sourceName] = true;
          }
          this.canEdit4Env = this.canEdit && this.editAllowed[node.sourceName];
        });
      }
    }
  }
}