import { Observable, of } from "rxjs";
import { map, tap } from "rxjs/operators";
import { THOUSAND } from "./constants";
import { Vertical } from "./enums";

enum Horizontal {
    Left = 1,
    Right
}

const HUNDRED = 100;
let outer: any;

of(1).pipe(map(value => outer)).subscribe();
                        ~~~~~                                                           [no-unsafe-scope]
of(1).pipe(map(value => outer = value)).subscribe();
                        ~~~~~                                                           [no-unsafe-scope]
of(1).pipe(map(function (value) { return outer = value; })).subscribe();
                                         ~~~~~                                          [no-unsafe-scope]
of(1).pipe(map(value => value * HUNDRED * THOUSAND)).subscribe();
of(1).pipe(tap(value => outer = value)).subscribe();
of(1).subscribe(value => outer = value);

of(1).pipe(
    map(() => Horizontal.Left),
    map(() => Vertical.Up)
).subscribe();
of("1").pipe(map(value => parseInt(value, 10))).subscribe();
of("1").pipe(map(value => window.parseInt(value, 10))).subscribe();
of("1").pipe(map(value => window.window.parseInt(value, 10))).subscribe();
of(1).pipe(map(value => Math.ceil(value))).subscribe();
of(1).pipe(map(value => Math.PI)).subscribe();
of(1).pipe(map(value => Number.MAX_SAFE_INTEGER)).subscribe();

function piped(outer: number): Observable<number> {
    return of(1).pipe(map(value => outer + value));
}

of(1).pipe(
    mergeMap(value => of(null).pipe(
        map(() => value)
    ))
).subscribe();

let outerArray = [];

of([]).pipe(
    map(array => array.slice())
).subscribe();

of([]).pipe(
    map(array => outerArray.slice())
                 ~~~~~~~~~~                                                             [no-unsafe-scope]
).subscribe();

of([]).pipe(
    map(array => array.length)
).subscribe();

of([]).pipe(
    map(array => outerArray.length)
                 ~~~~~~~~~~                                                             [no-unsafe-scope]
).subscribe();

class User {
    constructor(private name: string, private service: { bar(): string }) {
      of("Hello").pipe(
        map(value => {
          console.log(this.name);
                      ~~~~                                                              [no-unsafe-scope]
          return  value;
        })
      ).subscribe();
      of("Hello").pipe(map(value => `${value}, ${this.name}.`)).subscribe();
                                                 ~~~~                                   [no-unsafe-scope]
      of("Hello").pipe(map(value => this.name = value)).subscribe();
                                    ~~~~                                                [no-unsafe-scope]
      of("Hello").pipe(map(value => `${value}, ${this.foo()}.`)).subscribe();
      of("Hello").pipe(map(value => `${value}, ${this.service.bar()}.`)).subscribe();
      of("Hello").subscribe(value => this.name = value);
    }
    foo(): string { return "foo"; }
}

[no-unsafe-scope]: Unsafe scopes are forbidden