import { IActionCreator } from './action';
import { IActionMapBasic } from './action-map';
import { ActionHandlerCallback, createHandler } from './action-handler';
import { FlowfulError } from './error';

const className = 'ActionHandlerBuilder';

export class ActionHandlerBuilder<AM extends IActionMapBasic = IActionMapBasic, Inject = any> {
  private _name?: string;
  private _in?: readonly IActionCreator[];
  private _out?: readonly IActionCreator[];
  private _callback?: ActionHandlerCallback<AM, Inject>;
  private _inject?: Inject;

  constructor(name?: string) {
    this._name = name;
  }

  name(name: string): this {
    this._name = name;
    return this;
  }

  inputs(...inputs: readonly IActionCreator[]): this {
    if (!inputs.length) {
      throw new FlowfulError(
        `[Flowful][${className}][inputs/ins/in] At least one input action creator must be specified.`
      );
    }
    this._in = [...(this._in || []), ...inputs];
    return this;
  }

  in = this.inputs;
  ins = this.inputs;

  outputs(...outputs: readonly IActionCreator[]): this {
    if (!outputs.length) {
      throw new FlowfulError(
        `[Flowful][${className}][outputs/outs/out] At least one output action creator must be specified.`
      );
    }
    this._out = [...(this._out || []), ...outputs];
    return this;
  }

  out = this.outputs;
  outs = this.outputs;

  run(callback: ActionHandlerCallback<AM, Inject>): this {
    this._callback = callback;
    return this;
  }

  inject<T>(inject: T): ActionHandlerBuilder<AM, T> {
    this._inject = inject as unknown as Inject;
    return this as unknown as ActionHandlerBuilder<AM, T>;
  }

  create() {
    if (!this._in) {
      throw new FlowfulError(`[Flowful][${className}][create] Inputs must be specified for ActionHandler.`);
    }
    if (!this._callback) {
      throw new FlowfulError(`[Flowful][${className}][create] Run callback must be specified for ActionHandler.`);
    }

    return createHandler<AM, Inject>({
      name: this._name,
      inputs: this._in,
      outputs: this._out,
      run: this._callback,
      inject: this._inject,
    });
  }
}

export function buildHandler<AM extends IActionMapBasic = IActionMapBasic, Inject = any>(
  name?: string
): ActionHandlerBuilder<AM, Inject> {
  const builder = new ActionHandlerBuilder<AM, Inject>();
  if (name) {
    builder.name(name);
  }
  return builder;
}