/*
 * Tencent is pleased to support the open source community by making TMagicEditor available.
 *
 * Copyright (C) 2023 THL A29 Limited, a Tencent company.  All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { EventEmitter } from 'events';

import { isEmpty } from 'lodash-es';

import { DeprecatedEventConfig, EventConfig, HookType, MComponent, MContainer, MPage } from '@tmagic/schema';

import type App from './App';
import type Page from './Page';
import Store from './Store';

interface NodeOptions {
  config: MComponent | MContainer;
  page?: Page;
  parent?: Node;
  app: App;
}
class Node extends EventEmitter {
  public data: MComponent | MContainer | MPage;
  public style?: {
    [key: string]: any;
  };
  public events: DeprecatedEventConfig[] | EventConfig[];
  public instance?: any;
  public page?: Page;
  public parent?: Node;
  public app: App;
  public store = new Store();

  constructor(options: NodeOptions) {
    super();

    this.page = options.page;
    this.parent = options.parent;
    this.app = options.app;
    const { events } = options.config;
    this.data = options.config;
    this.events = events || [];
    this.listenLifeSafe();
  }

  public setData(data: MComponent | MContainer | MPage) {
    this.data = data;
    this.emit('updata-data');
  }

  public destroy() {
    this.removeAllListeners();
  }

  private listenLifeSafe() {
    this.once('created', async (instance: any) => {
      this.once('destroy', () => {
        this.instance = null;
        if (typeof this.data.destroy === 'function') {
          this.data.destroy(this);
        }

        this.listenLifeSafe();
      });

      this.instance = instance;
      await this.runCodeBlock('created');
    });

    this.once('mounted', async (instance: any) => {
      this.instance = instance;

      const eventConfigQueue = this.app.eventQueueMap[instance.config.id] || [];

      for (let eventConfig = eventConfigQueue.shift(); eventConfig; eventConfig = eventConfigQueue.shift()) {
        this.app.compActionHandler(eventConfig.eventConfig, eventConfig.fromCpt, eventConfig.args);
      }

      await this.runCodeBlock('mounted');
    });
  }

  private async runCodeBlock(hook: string) {
    if (typeof this.data[hook] === 'function') {
      // 兼容旧的数据格式
      await this.data[hook](this);
      return;
    }
    if (this.data[hook]?.hookType !== HookType.CODE || isEmpty(this.app.codeDsl)) return;
    for (const item of this.data[hook].hookData) {
      const { codeId, params = {} } = item;

      const functionContent = this.app.codeDsl?.[codeId]?.content;

      if (typeof functionContent === 'function') {
        await functionContent({ app: this.app, params });
      }
    }
  }
}

export default Node;
