// Copyright (C) 2018 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

import {TimeSpan} from '../common/time';

import {getStepSize, Tick, TickGenerator, TickType} from './gridline_helper';
import {TimeScale} from './time_scale';

const pattern1 = '|....:....';
const pattern2 = '|.:.';
const pattern5 = '|....';
const timeScale = new TimeScale(new TimeSpan(0, 1), [1, 2]);

test('gridline helper to have sensible step sizes', () => {
  expect(getStepSize(10, 14)).toEqual([1, pattern1]);
  expect(getStepSize(30, 14)).toEqual([5, pattern5]);
  expect(getStepSize(60, 14)).toEqual([5, pattern5]);
  expect(getStepSize(100, 14)).toEqual([10, pattern1]);

  expect(getStepSize(10, 21)).toEqual([0.5, pattern5]);
  expect(getStepSize(30, 21)).toEqual([2, pattern2]);
  expect(getStepSize(60, 21)).toEqual([5, pattern5]);
  expect(getStepSize(100, 21)).toEqual([5, pattern5]);

  expect(getStepSize(10, 3)).toEqual([5, pattern5]);
  expect(getStepSize(30, 3)).toEqual([10, pattern1]);
  expect(getStepSize(60, 3)).toEqual([20, pattern2]);
  expect(getStepSize(100, 3)).toEqual([50, pattern5]);

  expect(getStepSize(800, 4)).toEqual([200, pattern2]);
});

test('gridline helper to scale to very small and very large values', () => {
  expect(getStepSize(.01, 14)).toEqual([.001, pattern1]);
  expect(getStepSize(10000, 14)).toEqual([1000, pattern1]);
});

test('gridline helper to always return a reasonable number of steps', () => {
  for (let i = 1; i <= 1000; i++) {
    const [stepSize, _] = getStepSize(i, 14);
    expect(Math.round(i / stepSize)).toBeGreaterThanOrEqual(6);
    expect(Math.round(i / stepSize)).toBeLessThanOrEqual(14);
  }
});

describe('TickGenerator with range 0.0-1.0 and room for 2 labels', () => {
  let tickGen: TickGenerator|undefined = undefined;
  beforeAll(() => {
    const timeSpan = new TimeSpan(0.0, 1.0);
    const timeScale = new TimeScale(timeSpan, [0, 200]);
    tickGen = new TickGenerator(timeScale, {minLabelPx: 100});
  });
  it('should produce major ticks at 0.5s and minor ticks at 0.1s starting at 0',
     () => {
       const expected = [
         {type: TickType.MAJOR, time: 0.0},
         {type: TickType.MINOR, time: 0.1},
         {type: TickType.MINOR, time: 0.2},
         {type: TickType.MINOR, time: 0.3},
         {type: TickType.MINOR, time: 0.4},
         {type: TickType.MAJOR, time: 0.5},
         {type: TickType.MINOR, time: 0.6},
         {type: TickType.MINOR, time: 0.7},
         {type: TickType.MINOR, time: 0.8},
         {type: TickType.MINOR, time: 0.9},
       ];
       const actual = Array.from(tickGen!);
       expectTicksEqual(actual, expected);
     });
  it('should tell us to use 1 decimal place for labels', () => {
    expect(tickGen!.digits).toEqual(1);
  });
});

describe('TickGenerator with range 0.3-1.3 and room for 2 labels', () => {
  let tickGen: TickGenerator|undefined = undefined;
  beforeAll(() => {
    const timeSpan = new TimeSpan(0.3, 1.3);
    const timeScale = new TimeScale(timeSpan, [0, 200]);
    tickGen = new TickGenerator(timeScale, {minLabelPx: 100});
  });
  it('should produce major ticks at 0.5s and minor ticks at 0.1s starting at 0',
     () => {
       const expected = [
         {type: TickType.MINOR, time: 0.3},
         {type: TickType.MINOR, time: 0.4},
         {type: TickType.MAJOR, time: 0.5},
         {type: TickType.MINOR, time: 0.6},
         {type: TickType.MINOR, time: 0.7},
         {type: TickType.MINOR, time: 0.8},
         {type: TickType.MINOR, time: 0.9},
         {type: TickType.MAJOR, time: 1.0},
         {type: TickType.MINOR, time: 1.1},
         {type: TickType.MINOR, time: 1.2},
       ];
       const actual = Array.from(tickGen!);
       expectTicksEqual(actual, expected);
     });
  it('should tell us to use 1 decimal place for labels', () => {
    expect(tickGen!.digits).toEqual(1);
  });
});

describe('TickGenerator with range 0.0-0.2 and room for 1 label', () => {
  let tickGen: TickGenerator|undefined = undefined;
  beforeAll(() => {
    const timeSpan = new TimeSpan(0.0, 0.2);
    const timeScale = new TimeScale(timeSpan, [0, 100]);
    tickGen = new TickGenerator(timeScale, {minLabelPx: 100});
  });
  it('should produce major ticks at 0.2s and minor ticks at 0.1s starting at 0',
     () => {
       const expected = [
         {type: TickType.MAJOR, time: 0.0},
         {type: TickType.MINOR, time: 0.05},
         {type: TickType.MEDIUM, time: 0.1},
         {type: TickType.MINOR, time: 0.15},
       ];
       const actual = Array.from(tickGen!);
       expectTicksEqual(actual, expected);
     });
  it('should tell us to use 1 decimal place for labels', () => {
    expect(tickGen!.digits).toEqual(1);
  });
});

describe('TickGenerator with range 0.0-0.1 and room for 1 label', () => {
  let tickGen: TickGenerator|undefined = undefined;
  beforeAll(() => {
    const timeSpan = new TimeSpan(0.0, 0.1);
    const timeScale = new TimeScale(timeSpan, [0, 100]);
    tickGen = new TickGenerator(timeScale, {minLabelPx: 100});
  });
  it('should produce major ticks at 0.1s & minor ticks at 0.02s starting at 0',
     () => {
       const expected = [
         {type: TickType.MAJOR, time: 0.0},
         {type: TickType.MINOR, time: 0.01},
         {type: TickType.MINOR, time: 0.02},
         {type: TickType.MINOR, time: 0.03},
         {type: TickType.MINOR, time: 0.04},
         {type: TickType.MEDIUM, time: 0.05},
         {type: TickType.MINOR, time: 0.06},
         {type: TickType.MINOR, time: 0.07},
         {type: TickType.MINOR, time: 0.08},
         {type: TickType.MINOR, time: 0.09},
       ];
       const actual = Array.from(tickGen!);
       expect(tickGen!.digits).toEqual(1);
       expectTicksEqual(actual, expected);
     });
  it('should tell us to use 1 decimal place for labels', () => {
    expect(tickGen!.digits).toEqual(1);
  });
});

describe('TickGenerator with a very small timespan', () => {
  let tickGen: TickGenerator|undefined = undefined;
  beforeAll(() => {
    const timeSpan = new TimeSpan(0.0, 1e-9);
    const timeScale = new TimeScale(timeSpan, [0, 100]);
    tickGen = new TickGenerator(timeScale, {minLabelPx: 100});
  });
  it('should generate minor ticks at 2e-10s and one major tick at the start',
     () => {
       const expected = [
         {type: TickType.MAJOR, time: 0.0},
         {type: TickType.MINOR, time: 1e-10},
         {type: TickType.MINOR, time: 2e-10},
         {type: TickType.MINOR, time: 3e-10},
         {type: TickType.MINOR, time: 4e-10},
         {type: TickType.MEDIUM, time: 5e-10},
         {type: TickType.MINOR, time: 6e-10},
         {type: TickType.MINOR, time: 7e-10},
         {type: TickType.MINOR, time: 8e-10},
         {type: TickType.MINOR, time: 9e-10},
       ];
       const actual = Array.from(tickGen!);
       expectTicksEqual(actual, expected);
     });
  it('should tell us to use 9 decimal places for labels', () => {
    expect(tickGen!.digits).toEqual(9);
  });
});

describe('TickGenerator with a very large timespan', () => {
  let tickGen: TickGenerator|undefined = undefined;
  beforeAll(() => {
    const timeSpan = new TimeSpan(0.0, 1e9);
    const timeScale = new TimeScale(timeSpan, [0, 100]);
    tickGen = new TickGenerator(timeScale, {minLabelPx: 100});
  });
  it('should generate minor ticks at 2e8 and one major tick at the start',
     () => {
       const expected = [
         {type: TickType.MAJOR, time: 0.0},
         {type: TickType.MINOR, time: 1e8},
         {type: TickType.MINOR, time: 2e8},
         {type: TickType.MINOR, time: 3e8},
         {type: TickType.MINOR, time: 4e8},
         {type: TickType.MEDIUM, time: 5e8},
         {type: TickType.MINOR, time: 6e8},
         {type: TickType.MINOR, time: 7e8},
         {type: TickType.MINOR, time: 8e8},
         {type: TickType.MINOR, time: 9e8},
       ];
       const actual = Array.from(tickGen!);
       expectTicksEqual(actual, expected);
     });
  it('should tell us to use 0 decimal places for labels', () => {
    expect(tickGen!.digits).toEqual(0);
  });
});

describe('TickGenerator where the timespan has a dynamic range of 1e12', () => {
  // This is the equivalent of zooming in to the nanosecond level, 1000 seconds
  // into a trace Note: this is about the limit of what this generator can
  // handle.
  let tickGen: TickGenerator|undefined = undefined;
  beforeAll(() => {
    const timeSpan = new TimeSpan(1000, 1000.000000001);
    const timeScale = new TimeScale(timeSpan, [0, 100]);
    tickGen = new TickGenerator(timeScale, {minLabelPx: 100});
  });
  it('should generate minor ticks at 1e-10s and one major tick at the start',
     () => {
       const expected = [
         {type: TickType.MAJOR, time: 1000.0000000000},
         {type: TickType.MINOR, time: 1000.0000000001},
         {type: TickType.MINOR, time: 1000.0000000002},
         {type: TickType.MINOR, time: 1000.0000000003},
         {type: TickType.MINOR, time: 1000.0000000004},
         {type: TickType.MEDIUM, time: 1000.0000000005},
         {type: TickType.MINOR, time: 1000.0000000006},
         {type: TickType.MINOR, time: 1000.0000000007},
         {type: TickType.MINOR, time: 1000.0000000008},
         {type: TickType.MINOR, time: 1000.0000000009},
       ];
       const actual = Array.from(tickGen!);
       expectTicksEqual(actual, expected);
     });
  it('should tell us to use 9 decimal places for labels', () => {
    expect(tickGen!.digits).toEqual(9);
  });
});

describe(
    'TickGenerator where the timespan has a ridiculously huge dynamic range',
    () => {
      // We don't expect this to work, just wanna make sure it doesn't crash or
      // get stuck
      it('should not crash or get stuck in an infinite loop', () => {
        const timeSpan = new TimeSpan(1000, 1000.000000000001);
        const timeScale = new TimeScale(timeSpan, [0, 100]);
        new TickGenerator(timeScale);
      });
    });

describe(
    'TickGenerator where the timespan has a ridiculously huge dynamic range',
    () => {
      // We don't expect this to work, just wanna make sure it doesn't crash or
      // get stuck
      it('should not crash or get stuck in an infinite loop', () => {
        const timeSpan = new TimeSpan(1000, 1000.000000000001);
        const timeScale = new TimeScale(timeSpan, [0, 100]);
        new TickGenerator(timeScale);
      });
    });

test('TickGenerator constructed with a 0 width throws an error', () => {
  expect(() => {
    const timeScale = new TimeScale(new TimeSpan(0.0, 1.0), [0, 0]);
    new TickGenerator(timeScale);
  }).toThrow(Error);
});

test(
    'TickGenerator constructed with desiredPxPerStep of 0 throws an error',
    () => {
      expect(() => {
        new TickGenerator(timeScale, {minLabelPx: 0});
      }).toThrow(Error);
    });

test('TickGenerator constructed with a 0 duration throws an error', () => {
  expect(() => {
    const timeScale = new TimeScale(new TimeSpan(0.0, 0.0), [0, 1]);
    new TickGenerator(timeScale);
  }).toThrow(Error);
});

function expectTicksEqual(actual: Tick[], expected: any[]) {
  // TODO(stevegolton) We could write a custom matcher for this; this approach
  // produces cryptic error messages.
  expect(actual.length).toEqual(expected.length);
  for (let i = 0; i < actual.length; ++i) {
    const ex = expected[i];
    const ac = actual[i];
    expect(ac.type).toEqual(ex.type);
    expect(ac.time).toBeCloseTo(ex.time, 9);
  }
}