/**
 * @license
 * Copyright Google Inc. All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import {isBrowser} from '../../lib/common/utils';
import {isSafari, zoneSymbol} from '../test-util';

// simulate @angular/facade/src/error.ts
class BaseError extends Error {
  /** @internal **/
  _nativeError: Error;

  constructor(message: string) {
    super(message);
    const nativeError = new Error(message) as any as Error;
    this._nativeError = nativeError;
  }

  get message() { return this._nativeError.message; }
  set message(message) { this._nativeError.message = message; }
  get name() { return this._nativeError.name; }
  get stack() { return (this._nativeError as any).stack; }
  set stack(value) { (this._nativeError as any).stack = value; }
  toString() { return this._nativeError.toString(); }
}

class WrappedError extends BaseError {
  originalError: any;

  constructor(message: string, error: any) {
    super(`${message} caused by: ${error instanceof Error ? error.message : error}`);
    this.originalError = error;
  }

  get stack() {
    return ((this.originalError instanceof Error ? this.originalError : this._nativeError) as any)
        .stack;
  }
}

class TestError extends WrappedError {
  constructor(message: string, error: any) {
    super(`${message} caused by: ${error instanceof Error ? error.message : error}`, error);
  }

  get message() { return 'test ' + this.originalError.message; }
}

class TestMessageError extends WrappedError {
  constructor(message: string, error: any) {
    super(`${message} caused by: ${error instanceof Error ? error.message : error}`, error);
  }

  get message() { return 'test ' + this.originalError.message; }

  set message(value) { this.originalError.message = value; }
}

describe('ZoneAwareError', () => {
  // If the environment does not supports stack rewrites, then these tests will fail
  // and there is no point in running them.
  const _global: any = typeof window !== 'undefined' ? window : global;
  let config: any;
  const __karma__ = _global.__karma__;
  if (typeof __karma__ !== 'undefined') {
    config = __karma__ && (__karma__ as any).config;
  } else if (typeof process !== 'undefined') {
    config = process.env;
  }
  const policy = (config && config['errorpolicy']) || 'default';
  if (!(Error as any)['stackRewrite'] && policy !== 'disable') return;

  it('should keep error prototype chain correctly', () => {
    class MyError extends Error {}
    const myError = new MyError();
    expect(myError instanceof Error).toBe(true);
    expect(myError instanceof MyError).toBe(true);
    expect(myError.stack).not.toBe(undefined);
  });

  it('should instanceof error correctly', () => {
    let myError = Error('myError');
    expect(myError instanceof Error).toBe(true);
    let myError1 = Error.call(undefined, 'myError');
    expect(myError1 instanceof Error).toBe(true);
    let myError2 = Error.call(global, 'myError');
    expect(myError2 instanceof Error).toBe(true);
    let myError3 = Error.call({}, 'myError');
    expect(myError3 instanceof Error).toBe(true);
    let myError4 = Error.call({test: 'test'}, 'myError');
    expect(myError4 instanceof Error).toBe(true);
  });

  it('should return error itself from constructor', () => {
    class MyError1 extends Error {
      constructor() {
        const err: any = super('MyError1');
        this.message = err.message;
      }
    }
    let myError1 = new MyError1();
    expect(myError1.message).toEqual('MyError1');
    expect(myError1.name).toEqual('Error');
  });

  it('should return error by calling error directly', () => {
    let myError = Error('myError');
    expect(myError.message).toEqual('myError');
    let myError1 = Error.call(undefined, 'myError');
    expect(myError1.message).toEqual('myError');
    let myError2 = Error.call(global, 'myError');
    expect(myError2.message).toEqual('myError');
    let myError3 = Error.call({}, 'myError');
    expect(myError3.message).toEqual('myError');
  });

  it('should have browser specified property', () => {
    let myError = new Error('myError');
    if (Object.prototype.hasOwnProperty.call(Error.prototype, 'description')) {
      // in IE, error has description property
      expect((<any>myError).description).toEqual('myError');
    }
    if (Object.prototype.hasOwnProperty.call(Error.prototype, 'fileName')) {
      // in firefox, error has fileName property
      expect((<any>myError).fileName).toBeTruthy();
    }
  });

  it('should not use child Error class get/set in ZoneAwareError constructor', () => {
    const func = () => {
      const error = new BaseError('test');
      expect(error.message).toEqual('test');
    };

    expect(func).not.toThrow();
  });

  it('should behave correctly with wrapped error', () => {
    const error = new TestError('originalMessage', new Error('error message'));
    expect(error.message).toEqual('test error message');
    error.originalError.message = 'new error message';
    expect(error.message).toEqual('test new error message');

    const error1 = new TestMessageError('originalMessage', new Error('error message'));
    expect(error1.message).toEqual('test error message');
    error1.message = 'new error message';
    expect(error1.message).toEqual('test new error message');
  });

  it('should copy customized NativeError properties to ZoneAwareError', () => {
    const spy = jasmine.createSpy('errorCustomFunction');
    const NativeError = (global as any)[(Zone as any).__symbol__('Error')];
    NativeError.customFunction = function(args: any) { spy(args); };
    expect((Error as any)['customProperty']).toBe('customProperty');
    expect(typeof(Error as any)['customFunction']).toBe('function');
    (Error as any)['customFunction']('test');
    expect(spy).toHaveBeenCalledWith('test');
  });

  it('should always have stack property even without throw', () => {
    // in IE, the stack will be undefined without throw
    // in ZoneAwareError, we will make stack always be
    // there event without throw
    const error = new Error('test');
    const errorWithoutNew = Error('test');
    expect(error.stack !.split('\n').length > 0).toBeTruthy();
    expect(errorWithoutNew.stack !.split('\n').length > 0).toBeTruthy();
  });

  it('should show zone names in stack frames and remove extra frames', () => {
    if (policy === 'disable' || !(Error as any)['stackRewrite']) {
      return;
    }
    if (isBrowser && isSafari()) {
      return;
    }
    const rootZone = Zone.root;
    const innerZone = rootZone.fork({name: 'InnerZone'});

    rootZone.run(testFn);
    function testFn() {
      let outside: any;
      let inside: any;
      let outsideWithoutNew: any;
      let insideWithoutNew: any;
      try {
        throw new Error('Outside');
      } catch (e) {
        outside = e;
      }
      try {
        throw Error('Outside');
      } catch (e) {
        outsideWithoutNew = e;
      }
      innerZone.run(function insideRun() {
        try {
          throw new Error('Inside');
        } catch (e) {
          inside = e;
        }
        try {
          throw Error('Inside');
        } catch (e) {
          insideWithoutNew = e;
        }
      });

      if (policy === 'lazy') {
        outside.stack = outside.zoneAwareStack;
        outsideWithoutNew.stack = outsideWithoutNew.zoneAwareStack;
        inside.stack = inside.zoneAwareStack;
        insideWithoutNew.stack = insideWithoutNew.zoneAwareStack;
      }

      expect(outside.stack).toEqual(outside.zoneAwareStack);
      expect(outsideWithoutNew.stack).toEqual(outsideWithoutNew.zoneAwareStack);
      expect(inside !.stack).toEqual(inside !.zoneAwareStack);
      expect(insideWithoutNew !.stack).toEqual(insideWithoutNew !.zoneAwareStack);
      expect(typeof inside !.originalStack).toEqual('string');
      expect(typeof insideWithoutNew !.originalStack).toEqual('string');
      const outsideFrames = outside.stack !.split(/\n/);
      const insideFrames = inside !.stack !.split(/\n/);
      const outsideWithoutNewFrames = outsideWithoutNew !.stack !.split(/\n/);
      const insideWithoutNewFrames = insideWithoutNew !.stack !.split(/\n/);

      // throw away first line if it contains the error
      if (/Outside/.test(outsideFrames[0])) {
        outsideFrames.shift();
      }
      if (/Error /.test(outsideFrames[0])) {
        outsideFrames.shift();
      }

      if (/Outside/.test(outsideWithoutNewFrames[0])) {
        outsideWithoutNewFrames.shift();
      }
      if (/Error /.test(outsideWithoutNewFrames[0])) {
        outsideWithoutNewFrames.shift();
      }

      if (/Inside/.test(insideFrames[0])) {
        insideFrames.shift();
      }
      if (/Error /.test(insideFrames[0])) {
        insideFrames.shift();
      }

      if (/Inside/.test(insideWithoutNewFrames[0])) {
        insideWithoutNewFrames.shift();
      }
      if (/Error /.test(insideWithoutNewFrames[0])) {
        insideWithoutNewFrames.shift();
      }
      expect(outsideFrames[0]).toMatch(/testFn.*[<root>]/);

      expect(insideFrames[0]).toMatch(/insideRun.*[InnerZone]]/);
      expect(insideFrames[1]).toMatch(/testFn.*[<root>]]/);

      expect(outsideWithoutNewFrames[0]).toMatch(/testFn.*[<root>]/);

      expect(insideWithoutNewFrames[0]).toMatch(/insideRun.*[InnerZone]]/);
      expect(insideWithoutNewFrames[1]).toMatch(/testFn.*[<root>]]/);
    }
  });

  const zoneAwareFrames = [
    'Zone.run', 'Zone.runGuarded', 'Zone.scheduleEventTask', 'Zone.scheduleMicroTask',
    'Zone.scheduleMacroTask', 'Zone.runTask', 'ZoneDelegate.scheduleTask',
    'ZoneDelegate.invokeTask', 'zoneAwareAddListener', 'Zone.prototype.run',
    'Zone.prototype.runGuarded', 'Zone.prototype.scheduleEventTask',
    'Zone.prototype.scheduleMicroTask', 'Zone.prototype.scheduleMacroTask',
    'Zone.prototype.runTask', 'ZoneDelegate.prototype.scheduleTask',
    'ZoneDelegate.prototype.invokeTask', 'ZoneTask.invokeTask'
  ];

  function assertStackDoesNotContainZoneFrames(err: any) {
    const frames = policy === 'lazy' ? err.zoneAwareStack.split('\n') : err.stack.split('\n');
    if (policy === 'disable') {
      let hasZoneStack = false;
      for (let i = 0; i < frames.length; i++) {
        if (hasZoneStack) {
          break;
        }
        hasZoneStack = zoneAwareFrames.filter(f => frames[i].indexOf(f) !== -1).length > 0;
      }
      if (!hasZoneStack) {
        console.log('stack', err.originalStack);
      }
      expect(hasZoneStack).toBe(true);
    } else {
      for (let i = 0; i < frames.length; i++) {
        expect(zoneAwareFrames.filter(f => frames[i].indexOf(f) !== -1)).toEqual([]);
      }
    }
  };

  const errorZoneSpec = {
    name: 'errorZone',
    done: <(() => void)|null>null,
    onHandleError:
        (parentDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, error: Error) => {
          assertStackDoesNotContainZoneFrames(error);
          setTimeout(() => { errorZoneSpec.done && errorZoneSpec.done(); }, 0);
          return false;
        }
  };

  const errorZone = Zone.root.fork(errorZoneSpec);

  const assertStackDoesNotContainZoneFramesTest = function(testFn: Function) {
    return function(done: () => void) {
      errorZoneSpec.done = done;
      errorZone.run(testFn);
    };
  };

  describe('Error stack', () => {
    it('Error with new which occurs in setTimeout callback should not have zone frames visible',
       assertStackDoesNotContainZoneFramesTest(
           () => { setTimeout(() => { throw new Error('timeout test error'); }, 10); }));

    it('Error without new which occurs in setTimeout callback should not have zone frames visible',
       assertStackDoesNotContainZoneFramesTest(
           () => { setTimeout(() => { throw Error('test error'); }, 10); }));

    it('Error with new which cause by promise rejection should not have zone frames visible',
       (done) => {
         const p = new Promise(
             (resolve, reject) => { setTimeout(() => { reject(new Error('test error')); }); });
         p.catch(err => {
           assertStackDoesNotContainZoneFrames(err);
           done();
         });
       });

    it('Error without new which cause by promise rejection should not have zone frames visible',
       (done) => {
         const p = new Promise(
             (resolve, reject) => { setTimeout(() => { reject(Error('test error')); }); });
         p.catch(err => {
           assertStackDoesNotContainZoneFrames(err);
           done();
         });
       });

    it('Error with new which occurs in eventTask callback should not have zone frames visible',
       assertStackDoesNotContainZoneFramesTest(() => {
         const task = Zone.current.scheduleEventTask('errorEvent', () => {
           throw new Error('test error');
         }, undefined, () => null, undefined);
         task.invoke();
       }));

    it('Error without new which occurs in eventTask callback should not have zone frames visible',
       assertStackDoesNotContainZoneFramesTest(() => {
         const task = Zone.current.scheduleEventTask(
             'errorEvent', () => { throw Error('test error'); }, undefined, () => null, undefined);
         task.invoke();
       }));

    it('Error with new which occurs in longStackTraceZone should not have zone frames and longStackTraceZone frames visible',
       assertStackDoesNotContainZoneFramesTest(() => {
         const task = Zone.current.fork((Zone as any)['longStackTraceZoneSpec'])
                          .scheduleEventTask('errorEvent', () => {
                            throw new Error('test error');
                          }, undefined, () => null, undefined);
         task.invoke();
       }));

    it('Error without new which occurs in longStackTraceZone should not have zone frames and longStackTraceZone frames visible',
       assertStackDoesNotContainZoneFramesTest(() => {
         const task = Zone.current.fork((Zone as any)['longStackTraceZoneSpec'])
                          .scheduleEventTask('errorEvent', () => {
                            throw Error('test error');
                          }, undefined, () => null, undefined);
         task.invoke();
       }));

    it('stack frames of the callback in user customized zoneSpec should be kept',
       assertStackDoesNotContainZoneFramesTest(() => {
         const task = Zone.current.fork((Zone as any)['longStackTraceZoneSpec'])
                          .fork({
                            name: 'customZone',
                            onScheduleTask: (parentDelegate, currentZone, targetZone, task) => {
                              return parentDelegate.scheduleTask(targetZone, task);
                            },
                            onHandleError: (parentDelegate, currentZone, targetZone, error) => {
                              parentDelegate.handleError(targetZone, error);
                              const containsCustomZoneSpecStackTrace =
                                  error.stack.indexOf('onScheduleTask') !== -1;
                              expect(containsCustomZoneSpecStackTrace).toBeTruthy();
                              return false;
                            }
                          })
                          .scheduleEventTask('errorEvent', () => {
                            throw new Error('test error');
                          }, undefined, () => null, undefined);
         task.invoke();
       }));

    it('should be able to generate zone free stack even NativeError stack is readonly', function() {
      const _global: any =
          typeof window === 'object' && window || typeof self === 'object' && self || global;
      const NativeError = _global[zoneSymbol('Error')];
      const desc = Object.getOwnPropertyDescriptor(NativeError.prototype, 'stack');
      if (desc) {
        const originalSet: ((value: any) => void)|undefined = desc.set;
        // make stack readonly
        desc.set = null as any;

        try {
          const error = new Error('test error');
          expect(error.stack).toBeTruthy();
          assertStackDoesNotContainZoneFrames(error);
        } finally {
          desc.set = originalSet;
        }
      }
    });
  });
});