/**
 * 含有子组件的组件.
 *
 * @template O 组件的所有者
 * @template C 包含的子组件
 */
export abstract class ChildableComponent<
  O extends ComponentHost,
  C extends Component
> extends AbstractComponent<O> {
  /**
   *子组件对象
   */
  private _componentChildren?: { [name: string]: C };

  // 默认组件
  private _defaultComponents?: { [name: string]: ComponentClass<C> };

  /**
   * 创建新的组件
   */
  constructor(owner: O | typeof DUMMY_APPLICATION_OWNER) {
    super(owner);

    // 遍历默认组件加入当前组件中作为子组件使用
    _.entries(this._defaultComponents || {}).forEach(([name, component]) => {
      this.addComponent(name, component);
    });
  }

  /**
   * 通过名称获取子组件
   */
  getComponent(name: string): C | undefined {
    return (this._componentChildren || {})[name];
  }

  // 获取全部子组件
  getComponents(): C[] {
    return _.values(this._componentChildren);
  }

  // 是否存在该组件
  hasComponent(name: string): boolean {
    return !!(this._componentChildren || {})[name];
  }

  // 新增组件，存在就返回已经存在的组件，不存在则添加，同时触发新增组件事件
  addComponent<T extends C>(
    name: string,
    componentClass: T | ComponentClass<T, O>
  ): T {
    // 1. 组件存在就直接返回
    // 2. 组件未实例化则实例化，绑定到当前 this，已经实例化则直接保存
    // 3. 触发组件添加事件
  }

  removeComponent(name: string): C | undefined {
    // 1. 获取组件
    // 2. 停止组件的事件监听
    // 3. 从对象中删除组件
  }

  removeAllComponents() {
    // 1. 遍历组件，停止事件监听
    // 2. 组件对象清空
  }
}

/**
 * Component base class.  Has an owner (unless it's the application root component),
 * can dispatch events to its children, and has access to the root Application component.
 *
 * @template O type of component's owner.
 */
export abstract class AbstractComponent<O extends ComponentHost>
  extends EventDispatcher
  implements ComponentHost {
  /**
   * 所属对象
   */
  private _componentOwner: O | typeof DUMMY_APPLICATION_OWNER;

  /**
   * 组件名称 @Component 装饰器设置.
   */
  public componentName!: string;

  /**
   * 参数列表
   */
  private _componentOptions?: DeclarationOption[];

  constructor(owner: O | typeof DUMMY_APPLICATION_OWNER) {
    super();
    this._componentOwner = owner;
    this.initialize();
  }

  /**
   * 初始化
   */
  protected initialize() {}

  // 事件冒泡
  protected bubble(name: Event | EventMap | string, ...args: any[]) {
    super.trigger(name, ...args);

    if (
      this.owner instanceof AbstractComponent &&
      this._componentOwner !== DUMMY_APPLICATION_OWNER
    ) {
      this.owner.bubble(name, ...args);
    }

    return this;
  }

  /**
   * 返回组件的所有参数生声明
   */
  getOptionDeclarations(): DeclarationOption[] {
    return (this._componentOptions || []).slice();
  }

  /**
   * 返回根应用和组件
   */
  get application(): Application {
    return this._componentOwner === DUMMY_APPLICATION_OWNER
      ? ((this as any) as Application)
      : this._componentOwner.application;
  }

  /**
   * 组件所有者
   */
  get owner(): O {
    return this._componentOwner === DUMMY_APPLICATION_OWNER
      ? (this as any)
      : this._componentOwner;
  }
}

/**
 * 事件对象
 *
 * You may bind a callback to an event with `on` or remove with `off`;
 * `trigger`-ing an event fires all callbacks in succession.
 */
export class EventDispatcher {
  /**
   * 注册的事件处理对象
   */
  private _events?: EventHandlers;

  /**
   * Map of all objects this instance is listening to.
   */
  private _listeningTo?: EventListeners;

  /**
   * Map of all objects that are listening to this instance.
   */
  private _listeners?: EventListeners;

  /**
   * 唯一性 id
   */
  private get _listenId(): string {
    return this._savedListenId || (this._savedListenId = _.uniqueId("l"));
  }
  private _savedListenId?: string;

  /**
   * 绑定事件回调，类型为 all 时绑定所有事件
   */
  on(
    nameOrMap: EventMap | string,
    callback: EventCallback,
    context?: any,
    priority?: number
  ) {
    this.internalOn(nameOrMap, callback, context, priority);
    return this;
  }

  /**
   * Guard the `listening` argument from the public API.
   */
  private internalOn(
    name: EventMap | string,
    callback: EventCallback | undefined,
    context?: any,
    priority: number = 0,
    listening?: EventListener
  ) {
    this._events = eventsApi(
      onApi,
      this._events || <EventHandlers>{},
      name,
      callback,
      {
        context: context,
        ctx: this,
        listening: listening,
        priority: priority,
      }
    );

    if (listening) {
      const listeners = this._listeners || (this._listeners = {});
      listeners[listening.id] = listening;
    }
  }

  /**
   * 只绑定一次事件
   */

  once(
    name: EventMap | string,
    callback?: EventCallback,
    context?: any,
    priority?: number
  ) {
    // Map the event into a `{event: once}` object.
    const events = eventsApi(
      onceMap,
      <EventMap>{},
      name,
      callback,
      _.bind(this.off, this)
    );
    return this.on(events, void 0, context, priority);
  }

  /**
   * 移除事件回调
   */
  off(name?: EventMap | string, callback?: EventCallback, context?: any) {
    if (!this._events) {
      return this;
    }

    this._events = eventsApi(offApi, this._events, name, callback, {
      context: context,
      listeners: this._listeners,
    });

    return this;
  }

  /**
   * 监听其它对象的事件
   */
  listenTo(
    obj: EventDispatcher,
    name: EventMap | string,
    callback?: EventCallback,
    priority?: number
  ) {
    if (!obj) {
      return this;
    }
    const id = obj._listenId;
    const listeningTo = this._listeningTo || (this._listeningTo = {});
    let listening = listeningTo[id];

    // This object is not listening to any other events on `obj` yet.
    // Setup the necessary references to track the listening callbacks.
    if (!listening) {
      const thisId = this._listenId;
      listening = listeningTo[id] = {
        obj: obj,
        objId: id,
        id: thisId,
        listeningTo: listeningTo,
        count: 0,
      };
    }

    // Bind callbacks on obj, and keep track of them on listening.
    obj.internalOn(name, callback, this, priority, listening);
    return this;
  }

  /**
   * 监听其它对象事件一次
   */
  listenToOnce(
    obj: EventDispatcher,
    name: EventMap | string,
    callback?: EventCallback,
    priority?: number
  ) {
    // Map the event into a `{event: once}` object.
    const events = eventsApi(
      onceMap,
      <EventMap>{},
      name,
      callback,
      _.bind(this.stopListening, this, obj)
    );
    return this.listenTo(obj, events, void 0, priority);
  }

  /**
   * 停止监听事件
   */
  stopListening(
    obj?: EventDispatcher,
    name?: EventMap | string,
    callback?: EventCallback
  ) {
    const listeningTo = this._listeningTo;
    if (!listeningTo) {
      return this;
    }

    const ids = obj ? [obj._listenId] : _.keys(listeningTo);
    for (let i = 0; i < ids.length; i++) {
      const listening = listeningTo[ids[i]];

      // If listening doesn't exist, this object is not currently
      // listening to obj. Break out early.
      if (!listening) {
        break;
      }

      listening.obj.off(name, callback, this);
    }

    if (_.isEmpty(listeningTo)) {
      this._listeningTo = void 0;
    }

    return this;
  }

  /**
   * 触发事件
   */
  trigger(name: Event | EventMap | string, ...args: any[]) {
    if (!this._events) {
      return this;
    }

    if (name instanceof Event) {
      triggerApi(
        this._events,
        name.name,
        void 0,
        [name],
        (events: EventHandler[], args: any[]) => {
          let ev: EventHandler,
            i = -1,
            l = events.length;
          while (++i < l) {
            if (name.isPropagationStopped) {
              return;
            }
            ev = events[i];
            ev.callback.apply(ev.ctx, args);
          }
        }
      );
    } else {
      eventsApi(triggerApi, this._events, name, void 0, args);
    }

    return this;
  }
}

import { Application } from "./application";
import { BindOption } from "./utils/options";
import { TypeDocAndTSOptions } from "./utils/options/declaration";

export const enum ExitCode {
  OptionError = 1,
  NoInputFiles = 2,
  NoOutput = 3,
  CompileError = 4,
  OutputError = 5,
}

export class CliApplication extends Application {
  @BindOption("out")
  out!: string;

  @BindOption("json")
  json!: string;

  @BindOption("version")
  version!: boolean;

  @BindOption("help")
  help!: boolean;

  /**
   * Run TypeDoc from the command line.
   */
  bootstrap(options?: Partial<TypeDocAndTSOptions>) {
    // 其它代码
    const result = super.bootstrap(options);
    // 其它代码
    const src = this.expandInputFiles(result.inputFiles);
    const project = this.convert(src);
    if (project) {
      if (this.out) {
        this.generateDocs(project, this.out);
      }
      if (this.json) {
        this.generateJson(project, this.json);
      }
      if (!this.out && !this.json) {
        this.generateDocs(project, "./docs");
      }
    }
    // 其它代码
    return result;
  }
}

export class Application extends ChildableComponent<
  Application,
  AbstractComponent<Application>
> {
  /**
   * The converter used to create the declaration reflections.
   */
  converter: Converter;

  /**
   * The renderer used to generate the documentation output.
   */
  renderer: Renderer;

  /**
   * The serializer used to generate JSON output.
   */
  serializer: Serializer;

  // 其它属性

  /**
   * Create a new TypeDoc application instance.
   *
   * @param options An object containing the options that should be used.
   */
  constructor() {
    super(DUMMY_APPLICATION_OWNER);

    this.logger = new ConsoleLogger();
    this.options = new Options(this.logger);
    this.options.addDefaultDeclarations();
    this.serializer = new Serializer();
    this.converter = this.addComponent<Converter>("converter", Converter);
    this.renderer = this.addComponent<Renderer>("renderer", Renderer);
    this.plugins = this.addComponent("plugins", PluginHost);
  }

  /**
   * Initialize TypeDoc with the given options object.
   *
   * @param options  The desired options to set.
   */
  bootstrap(
    options: Partial<TypeDocAndTSOptions> = {}
  ): { hasErrors: boolean; inputFiles: string[] } {
    // 日志相关配置

    this.plugins.load();

    this.options.reset();
    this.options.setValues(options).mapErr((errors) => {
      for (const error of errors) {
        this.logger.error(error.message);
      }
    });
    this.options.read(this.logger);

    return {
      hasErrors: this.logger.hasErrors(),
      inputFiles: this.inputFiles,
    };
  }

  /**
   * Run the converter for the given set of files and return the generated reflections.
   *
   * @param src  A list of source that should be compiled and converted.
   * @returns An instance of ProjectReflection on success, undefined otherwise.
   */
  public convert(src: string[]): ProjectReflection | undefined {
    const result = this.converter.convert(src);
    // 其它代码
    return result.project;
  }

  /**
   * Run the documentation generator for the given set of files.
   *
   * @param out  The path the documentation should be written to.
   * @returns TRUE if the documentation could be generated successfully, otherwise FALSE.
   */
  public generateDocs(
    input: ProjectReflection | string[],
    out: string
  ): boolean {
    const project =
      input instanceof ProjectReflection ? input : this.convert(input);

    out = Path.resolve(out);
    this.renderer.render(project, out);
  }

  /**
   * Run the converter for the given set of files and write the reflections to a json file.
   *
   * @param out  The path and file name of the target file.
   * @returns TRUE if the json file could be written successfully, otherwise FALSE.
   */
  public generateJson(
    input: ProjectReflection | string[],
    out: string
  ): boolean {
    const project =
      input instanceof ProjectReflection ? input : this.convert(input);
    if (!project) {
      return false;
    }

    out = Path.resolve(out);
    const eventData = {
      outputDirectory: Path.dirname(out),
      outputFile: Path.basename(out),
    };
    const ser = this.serializer.projectToObject(project, {
      begin: eventData,
      end: eventData,
    });
    writeFile(out, JSON.stringify(ser, null, "\t"), false);

    return true;
  }

  /**
   * Expand a list of input files.
   *
   * Searches for directories in the input files list and replaces them with a
   * listing of all TypeScript files within them. One may use the ```--exclude``` option
   * to filter out files with a pattern.
   *
   * @param inputFiles  The list of files that should be expanded.
   * @returns  The list of input files with expanded directories.
   */
  public expandInputFiles(inputFiles: string[] = []): string[] {
    const files: string[] = [];

    const exclude = this.exclude ? createMinimatch(this.exclude) : [];

    function isExcluded(fileName: string): boolean {
      return exclude.some((mm) => mm.match(fileName));
    }

    const supportedFileRegex = this.options.getCompilerOptions().allowJs
      ? /\.[tj]sx?$/
      : /\.tsx?$/;
    function add(file: string, entryPoint: boolean) {
      let stats: FS.Stats;
      try {
        stats = FS.statSync(file);
      } catch {
        // No permission or a symbolic link, do not resolve.
        return;
      }
      const fileIsDir = stats.isDirectory();
      if (fileIsDir && !file.endsWith("/")) {
        file = `${file}/`;
      }

      if ((!fileIsDir || !entryPoint) && isExcluded(file.replace(/\\/g, "/"))) {
        return;
      }

      if (fileIsDir) {
        FS.readdirSync(file).forEach((next) => {
          add(Path.join(file, next), false);
        });
      } else if (supportedFileRegex.test(file)) {
        files.push(file);
      }
    }

    inputFiles.forEach((file) => {
      add(Path.resolve(file), true);
    });

    return files;
  }
}