import { ComponentFixture, TestBed } from '@angular/core/testing';
import { buildPaginatedList, PaginatedList } from '../../core/data/paginated-list.model';
import { PageInfo } from '../../core/shared/page-info.model';
import { Observable } from 'rxjs/internal/Observable';
import { of as observableOf } from 'rxjs/internal/observable/of';
import { UnCacheableObject } from '../../core/shared/uncacheable-object.model';
import { RequestEntryState } from '../../core/data/request-entry-state.model';
import { RequestEntry } from '../../core/data/request-entry.model';

/**
 * Returns true if a Native Element has a specified css class.
 *
 * @param element
 *    the Native Element
 * @param className
 *    the class name to find
 */
export const hasClass = (element: any, className: string): boolean => {
  const classes = element.getAttribute('class');
  return classes.split(' ').indexOf(className) !== -1;
};

/**
 * Creates an instance of a component and returns test fixture.
 *
 * @param html
 *    the component's template as html
 * @param type
 *    the type of the component to instantiate
 */
export const createTestComponent = <T>(html: string, type: new (...args: any[]) => T ): ComponentFixture<T> => {
  TestBed.overrideComponent(type, {
    set: { template: html }
  });
  const fixture = TestBed.createComponent(type);

  fixture.detectChanges();
  return fixture as ComponentFixture<T>;
};

/**
 * Allows you to spy on a read only property
 *
 * @param obj
 *    The object to spy on
 * @param prop
 *    The property to spy on
 */
export function spyOnOperator(obj: any, prop: string): any {
  const oldProp = obj[prop];
  Object.defineProperty(obj, prop, {
    configurable: true,
    enumerable: true,
    value: oldProp,
    writable: true
  });

  return spyOn(obj, prop);
}

/**
 * Method to create a paginated list for an array of objects
 * @param objects An array representing the paginated list's page
 */
export function createPaginatedList<T>(objects?: T[]): PaginatedList<T> {
  return buildPaginatedList(new PageInfo(), objects);
}

/**
 * Creates a jasmine spy for an exported function
 * @param target The object to spy on
 * @param prop The property/function to spy on
 */
export function spyOnExported<T>(target: T, prop: keyof T): jasmine.Spy {
  const spy = jasmine.createSpy(`${String(prop)}Spy`);
  spyOnProperty(target, prop).and.returnValue(spy);
  return spy;
}

/**
 * Create a mock request entry to be used in testing
 * @param unCacheableObject
 * @param statusCode
 * @param errorMessage
 */
export function createRequestEntry$(unCacheableObject?: UnCacheableObject, statusCode = 200, errorMessage?: string): Observable<RequestEntry> {
  return observableOf({
    request: undefined,
    state: RequestEntryState.Success,
    response: {
      timeCompleted: new Date().getTime(),
      statusCode,
      errorMessage,
      unCacheableObject
    },
    lastUpdated: new Date().getTime()
  });
}

/**
 * Get the argument (method parameter) a Spy method got called with first
 * Example case:
 * - We spy on method mock(testNumber: number)
 * - During the tests, mock gets called 3 times with numbers 8, 5 and 7
 * - This function will return 8, as it's the first number mock got called with
 * @param spyMethod     The method that got spied on
 * @param argumentIndex The index of the argument, only necessary if the spy method contains more than one parameter
 */
export function getFirstUsedArgumentOfSpyMethod(spyMethod: jasmine.Spy, argumentIndex: number = 0): any {
  return spyMethod.calls.argsFor(0)[argumentIndex];
}
