import { OptionSource } from '../Sources/OptionSource';
import { Option, OptionValue } from '../Option';
import { EnvSource } from '../Sources/EnvSource';
import { ErrorCallback } from '../ErrorCallback';
import { ArgSource } from '../Sources/ArgSource';
import { ConfigSource } from '../Sources/ConfigSource';
import { TypeValidation } from '../TypeValidation/TypeValidation';

export abstract class BaseOption<T> {
  protected readonly sources: OptionSource[] = [];
  private _config: Option;

  public constructor (
    config: Option,
    error_callback?: ErrorCallback,
    exit_on_interrupt = true
  ) {
    this._config = config;

    const sources = config.sources || {};
    if (typeof sources.configs !== 'undefined')
      this.sources.push (new ConfigSource (sources.configs, error_callback));

    if (sources.env !== false)
      this.sources.push (new EnvSource (error_callback));

    if (sources.console !== false)
      this.sources.push (new ArgSource (error_callback));

    if (sources.interactive !== false) {
      this.sources.push (new InteractiveSource (
        exit_on_interrupt,
        error_callback
      ));
    }
  }

  protected abstract get validation(): TypeValidation;

  public async parse (): Promise<T> {
    const val = new OptionValue (this.validation);

    for (const source of this.sources)
      // eslint-disable-next-line no-await-in-loop
      await source.parse (this._config, val);

    if (!val.assinged)
      return this._config.default;
    return val.value;
  }
}