export function getService<T>(name: string): T {
  const { owner } = getContext();

  const service = owner.lookup<T>(`service:${name}`);

  return service;
}

export async function refresh(mocking: () => void = () => undefined) {
  const url = currentURL();
  const ctx = getContext();
  await teardownContext(ctx);
  await setupContext(ctx);
  await mocking();
  await visit(url);
}

export const textFor = (selector: string): string => {
  const context = getContext();
  const root = context.element;

  const element = root.querySelector(selector);
  const content = element && element.textContent;
  const text = (content && content.trim()) || '';

  return text;
};

async function cleanEverything() {
  const context = getContext();
  if (context) {
    const adapter = context.owner.lookup('adapter:application');

    await adapter.cache.clear();
  }

  // specifically, offline storage
  await localforage.clear();
  await localStorage.clear();
}

export const stubService = (name: string, hash = {}, injections?: IInjection[]) => {
  let stubbedService;

  // TODO: need to be able to use an extended service that uses services. :)
  if (hash instanceof Function) {
    stubbedService = hash;
  } else {
    stubbedService = Service.extend(hash);
  }

  let { owner } = getContext();
  let serviceName = `service:${name}`;

  owner.register(serviceName, stubbedService);

  if (injections) {
    injections.forEach(injection => {
      owner.application.inject(injection.in, injection.as, serviceName);
    });
  }
};