1/*
2 * Copyright (c) 2022-2023 Shenzhen Kaihong Digital Industry Development Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http:// www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16const { NapiLog } = require('./NapiLog');
17const { NodeTools, DataType, NodeType } = require('./NodeTools');
18const re = require('./re');
19
20class ModifyNode {}
21
22function getParent(node, dest, parent) {
23  return dest.parent_;
24}
25
26function isNameRepeat(node, name) {
27  for (let i in node.value_) {
28    if (node.value_[i].name_ === name) {
29      return true;
30    }
31  }
32  return false;
33}
34
35ModifyNode.modifyName = function (files, root, node, name) {
36  let parent = getParent(root, node, null);
37  if (parent === null) {
38    NapiLog.logError("Can't change root node name");
39    return false;
40  }
41  node.name_ = name;
42  return true;
43};
44
45ModifyNode.modifyNodeType = function (files, root, node, type) {
46  let parent = getParent(root, node, null);
47  if (parent === null) {
48    NapiLog.logError("Can't change root node type");
49    return false;
50  }
51  switch (type) {
52    case NodeType.COPY:
53    case NodeType.INHERIT:
54    case NodeType.REFERENCE:
55      node.ref_ = 'unknow';
56      break;
57    case NodeType.DELETE:
58      break;
59    case NodeType.TEMPLETE:
60      break;
61  }
62  node.nodeType_ = type;
63  return true;
64};
65
66ModifyNode.addChildAttr = function (root, node) {
67  for (let i = 1; i < 256; i++) {
68    let name = 'attr_' + i;
69    if (!isNameRepeat(node, name)) {
70      let newAttr = NodeTools.createNewNode(
71        DataType.ATTR,
72        name,
73        NodeTools.createNewNode(DataType.INT8, '', 0)
74      );
75      node.value_.push(newAttr);
76      newAttr.parent_ = node;
77      newAttr.value_.parent_ = newAttr;
78      return newAttr;
79    }
80  }
81};
82
83ModifyNode.addChildNode = function (root, node) {
84  for (let i = 1; i < 256; i++) {
85    let name = 'node_' + i;
86    if (!isNameRepeat(node, name)) {
87      let newNode = NodeTools.createNewNode(
88        DataType.NODE,
89        name,
90        [],
91        NodeType.DATA
92      );
93      node.value_.push(newNode);
94      newNode.parent_ = node;
95      return newNode;
96    }
97  }
98};
99
100ModifyNode.deleteNode = function (node) {
101  let parent = node.parent_;
102  if (parent === null) {
103    NapiLog.logError('不能删除root节点');
104    return false;
105  }
106  for (let i in parent.value_) {
107    if (parent.value_[i] === node) {
108      parent.value_.splice(i, 1);
109      return;
110    }
111  }
112};
113
114ModifyNode.getInheritList = function (root, node) {
115  let ret = [];
116  let parent = getParent(root, node, null);
117  if (parent === null) {
118    return ret;
119  }
120
121  for (let i in parent.value_) {
122    let pn = parent.value_[i];
123    if (pn.type_ === DataType.NODE && pn.nodeType_ === NodeType.TEMPLETE) {
124      ret.push(pn);
125    }
126  }
127  let ps = [parent];
128  while (true) {
129    let pp = getParent(root, parent, null);
130    if (pp === null) {
131      break;
132    }
133    ps.splice(0, 0, pp);
134  }
135  let ptemp = null;
136  for (let i in ps) {
137    if (ps[i].nodeType_ === NodeType.INHERIT) {
138      ptemp = NodeTools.findChildByName(ptemp, ps[i].ref_);
139    } else if (ptemp === null) {
140      ptemp = ps[i];
141    } else {
142      ptemp = NodeTools.findChildByName(ptemp, ps[i].name_);
143    }
144    if (ptemp === null) {
145      break;
146    }
147  }
148  if (ptemp !== null && ptemp !== parent) {
149    for (let i in ptemp.value_) {
150      let pn = ptemp.value_[i];
151      if (pn.type_ === DataType.NODE && pn.nodeType_ === NodeType.TEMPLETE) {
152        ret.push(pn);
153      }
154    }
155  }
156
157  return ret;
158};
159ModifyNode.getInheritNameList = function (root, node) {
160  let nodes = ModifyNode.getInheritList(root, node);
161  let ret = [];
162  for (i in nodes) {
163    ret.push(nodes[i].name_);
164  }
165  return ret;
166};
167ModifyNode.getInheritTemplete = function (root, node) {
168  let parent = getParent(root, node, null);
169  if (parent === null) {
170    return null;
171  }
172  let ilist = ModifyNode.getInheritList(root, node);
173  for (let i in ilist) {
174    if (parent.nodeType_ === NodeType.TEMPLETE) {
175      if (parent.ref_ === ilist[i].name_) {
176        return ilist[i];
177      }
178    } else if (parent.name_ === ilist[i].name_) {
179      return ilist[i];
180    }
181  }
182  return null;
183};
184
185module.exports = {
186  ModifyNode,
187};
188