export class Observable<T> {
  private _subscribe: Subscribe<T>;
  private _observers: Identified<Observer<T>>[] = [];

  constructor(subscribe?: Subscribe<T>) {
    this._subscribe = subscribe;
  }

  subscribe(Observer?: Observer<T>): Subscription;
  subscribe(
    next?: NextObserver<T>,
    error?: ErrorObserver,
    complete?: CompleteObserver
  ): Subscription;

  subscribe(
    observer?: Observer<T> | NextObserver<T>,
    error?: ErrorObserver,
    complete?: CompleteObserver
  ): Subscription {
    if (!observer) observer = () => { };

    if (!error) error = () => { };

    if (!complete) complete = () => { };

    let _observer = {} as Identified<Observer<T>>;

    _observer.next = value => {
      if (!this._observers.find(({ id }) => _observer.id === id)) return;
      (observer['next'] || observer)(value);
    };

    _observer.error = value => {
      if (!this._observers.find(({ id }) => _observer.id === id)) return;
      (observer['error'] || error)(value);
    };

    _observer.complete = () => {
      if (!this._observers.find(({ id }) => _observer.id === id)) return;
      this._observers = this._observers.filter(({ id }) => _observer.id !== id);
      (observer['complete'] || complete)();
    };

    _observer.id = this._observers.length;

    this._observers.push(_observer);
    this._subscribe(_observer);

    return {
      unsubscribe: () =>
        this._observers = this._observers.filter(({ id }) => _observer.id !== id)
    };
  }
}

export type Subscribe<T> = (observer: Observer<T>) => Subscription;

export type NextObserver<T> = (value?: T) => void;
export type ErrorObserver = (error?: any) => void;
export type CompleteObserver = () => void;

export interface Observer<T> {
  next?: NextObserver<T>;
  error?: ErrorObserver;
  complete?: CompleteObserver;
}

export type Identified<T> = Partial<T> & { id: any };

export interface Subscription {
  unsubscribe(): void;
}