import { applyMiddleware, createStore, compose } from "redux";

import installBrowserRouter from "./action-router";
import addChangeUrlEvent from "./change-url-event.js";
import addMissingHistoryEvents from "./history-events.js";

const console_log = console.log;
console.log = () => {};
function with_console(cb) {
  console.log = console_log;
  try {
    cb();
  } catch (e) {
    console.log = () => {};
    throw e;
  }
  console.log = () => {};
}

function createLocation(path) {
  return {
    hash: "#hash",
    host: "example.com",
    hostname: "example",
    origin: "",
    href: "",
    pathname: path,
    port: 80,
    protocol: "https:"
  };
}

function createFakeWindow(path = "/path/to/thing") {
  let locations = [createLocation("(root)")];
  function pushLocation(window, path) {
    let newLoc = createLocation(path);
    locations.push(newLoc);
    window.location = newLoc;
    return newLoc;
  }
  function popLocation(window) {
    locations.pop();
    let newLoc = locations[locations.length - 1];
    window.location = newLoc;
    return newLoc;
  }

  const window = {
    history: {
      pushState: jest.fn((_, __, path) => {
        window.location = pushLocation(window, path);
      }),
      replaceState: jest.fn()
    }
  };

  pushLocation(window, path);
  const map = {};

  window.addEventListener = jest.fn((event, cb) => {
    map[event] = cb;
  });

  function prepareEvent(window, evName) {
    if (evName == "popstate") {
      window.location = popLocation(window);
    }
  }

  window.dispatchEvent = jest.fn(ev => {
    const evName = ev.type;
    if (map[evName]) {
      prepareEvent(window, evName);
      map[evName].handleEvent(ev);
    }
  });

  return window;
}

function setupTest(routesConfig, path = "/path/to/thing") {
  const window = createFakeWindow(path);
  const mockPushState = window.history.pushState;
  addMissingHistoryEvents(window, window.history);
  addChangeUrlEvent(window, window.history);

  const { enhancer, init } = installBrowserRouter(routesConfig, window);
  const reduce = jest.fn();

  const store = createStore(reduce, enhancer);

  function urlChanges() {
    return mockPushState.mock.calls.map(item => item[2]);
  }

  function actionsDispatched() {
    return reduce.mock.calls.map(item => item[1]).slice(1);
  }

  function fireUrlChange(path) {
    window.dispatchEvent(
      new CustomEvent("urlchanged", { detail: createLocation(path) })
    );
  }

  return {
    store,
    reduce,
    window,
    urlChanges,
    actionsDispatched,
    fireUrlChange,
    init
  };
}

it("router handles exact match in preference to wildcard match", () => {
  //given
  const actionType = "THE_ACTION";
  const action = { type: actionType, id: 1 };
  const routesConfig = [
    ["/somewhere/:id", actionType, {}],
    ["/somewhere", actionType, { id: 1 }]
  ];
  const { urlChanges, store } = setupTest(routesConfig);

  // when
  store.dispatch(action);

  // then
  expect(urlChanges()).toEqual(["/somewhere"]);
});

it("router doees not dispatch an action from url change that is caused by action dispatch", () => {
  //given
  const actionType = "THE_ACTION";
  const id = "1";
  const view = "home";
  const action = { type: actionType, id, view };
  const routesConfig = [
    ["/somewhere/:id/:view", actionType, {}],
    ["/somewhere/:id/default", actionType, { view: "home" }]
  ];
  const { urlChanges, store, actionsDispatched, init } = setupTest(
    routesConfig
  );

  // when
  store.dispatch(action);

  // then
  expect(actionsDispatched()).toEqual([action]);
});

it("popstate doesn't cause a pushstate", () => {
  //given
  const actionType = "THE_ACTION";
  const id = "1";
  const view = "home";
  const action = { type: actionType, id, view };
  const routesConfig = [
    ["/somewhere/:id/:view", actionType, {}],
    ["/somewhere/:id/default", actionType, { view: "home" }]
  ];

  const {
    urlChanges,
    store,
    actionsDispatched,
    fireUrlChange,
    init,
    window
  } = setupTest(routesConfig, "/somewhere/foo/default");

  init();
  window.history.pushState({}, "", "/somwhere/bar/default");

  // when
  window.dispatchEvent(new CustomEvent("popstate", {}));

  // then
  expect(urlChanges().length).toEqual(1);
});

it("router handles wildcard with extra args correctly", () => {
  //given
  const actionType = "THE_ACTION";
  const action = { type: actionType, id: 1, view: "home" };
  const routesConfig = [
    ["/somewhere/:id/:view", actionType, {}],
    ["/somewhere/:id/default", actionType, { view: "home" }]
  ];
  const { urlChanges, store } = setupTest(routesConfig);

  // when
  store.dispatch(action);

  // then
  expect(urlChanges()).toEqual(["/somewhere/1/default"]);
});

it("router handles wildcard with extraArgs correctly with reverse order", () => {
  //given
  const actionType = "THE_ACTION";
  const action = { type: actionType, id: 1, view: "home" };
  const routesConfig = [
    ["/somewhere/:id/default", actionType, { view: "home" }],
    ["/somewhere/:id/:view", actionType, {}]
  ];
  const { urlChanges, store } = setupTest(routesConfig);

  // when
  store.dispatch(action);

  // then
  expect(urlChanges()).toEqual(["/somewhere/1/default"]);
});

it("router handles wildcard without extraArgs correctly", () => {
  //given
  const actionType = "THE_ACTION";
  const action = { type: actionType, id: 1 };
  const routesConfig = [["/somewhere/:id/default", actionType, {}]];
  const { urlChanges, store } = setupTest(routesConfig);

  // when
  store.dispatch(action);

  // then
  expect(urlChanges()).toEqual(["/somewhere/1/default"]);
});

it("router handles wildcard with no match correctly", () => {
  //given
  const actionType = "THE_ACTION";
  const action = { type: actionType, foo: 1 };
  const routesConfig = [["/somewhere/:id/default", actionType, {}]];
  const { urlChanges, store } = setupTest(routesConfig);

  // when
  store.dispatch(action);

  // then ( no url changes triggered)
  expect(urlChanges()).toEqual([]);
});

it("router does not match when all args are not accounted for", () => {
  //given
  const actionType = "THE_ACTION";
  const action = { type: actionType, id: 1, view: "home" };
  const routesConfig = [["/somewhere/:id/default", actionType, {}]];
  const { urlChanges, store } = setupTest(routesConfig);

  // when
  store.dispatch(action);

  // then ( no url changes triggered)
  expect(urlChanges()).toEqual([]);
});

it("router should match non-wildcard route in preference to wildcard route", () => {
  // given
  const routesConfig = [
    ["/somewhere/:id", "ACTION_NAME", {}],
    ["/somewhere/specific", "ACTION_NAME", { id: 1 }]
  ];
  const { actionsDispatched, fireUrlChange } = setupTest(routesConfig);

  // when
  fireUrlChange("/somewhere/specific");

  // then
  expect(actionsDispatched()).toEqual([{ type: "ACTION_NAME", id: 1 }]);
});

it("router should throw on duplicate paths", () => {
  // given
  const routesConfig = [
    ["/somewhere/:id", "ACTION_NAME", {}],
    ["/somewhere/:id", "ACTION_NAME", {}]
  ];

  expect(() => {
    setupTest(routesConfig);
  }).toThrow();
});

it("router should throw on equally specific routes", () => {
  // given
  const routesConfig = [
    ["/somewhere/:id", "ACTION_NAME", {}],
    ["/somewhere/:specific", "ACTION_NAME", {}]
  ];

  expect(() => {
    setupTest(routesConfig);
  }).toThrow();
});

it("router should match less-wildcarded routes in preference to more wildcarded routes", () => {
  //given
  const routesConfig = [
    ["/somewhere/:id/:view/:bar", "ACTION_NAME", {}],
    ["/somewhere/:foo/:id/:view/:baz", "ACTION_NAME", {}]
  ];
  const { actionsDispatched, fireUrlChange } = setupTest(routesConfig);

  // when
  fireUrlChange("/somewhere/specific/etc/bar");

  // then
  expect(actionsDispatched()).toEqual([
    { type: "ACTION_NAME", id: "specific", view: "etc", bar: "bar" }
  ]);
});

it("router should propagate matches through non-matching cases", () => {
  //given
  const routesConfig = [
    ["/somewhere/specific/:view", "ACTION_NAME", { id: 1 }],
    ["/somewhere/:id/:view", "ACTION_NAME", {}],
    ["/not/a/match", "ACTION_NAME", {}]
  ];
  const { actionsDispatched, fireUrlChange } = setupTest(routesConfig);

  // when
  fireUrlChange("/somewhere/specific/etc");

  // then
  expect(actionsDispatched()).toEqual([
    { type: "ACTION_NAME", id: 1, view: "etc" }
  ]);
});

it("router should give precedence to exact match first in equally-specific routes (/a/:b vs /:a/b)", () => {
  // given
  const routesConfig = [
    ["/something/:dynamic", "ACTION_NAME", {}],
    ["/:dyn/something", "ACTION_NAME", {}]
  ];
  const { actionsDispatched, fireUrlChange } = setupTest(routesConfig);

  // when
  fireUrlChange("/something/something");

  // then
  expect(actionsDispatched()).toEqual([
    { type: "ACTION_NAME", dynamic: "something" }
  ]);
});

it("router handles the current location when initialized", () => {
  // given
  const routesConfig = [
    ["/something/:dynamic", "ACTION_NAME", {}],
    ["/:dyn/something", "ACTION_NAME", {}]
  ];

  // when
  /// We break the pattern because we're testing store construction.
  const { actionsDispatched, init } = setupTest(
    routesConfig,
    "/something/something"
  );
  init();

  // then
  expect(actionsDispatched()).toEqual([
    { type: "ACTION_NAME", dynamic: "something" }
  ]);
});

it("pathForAction should render a route", () => {
  // given
  const routesConfig = [
    ["/something/:dynamic", "ACTION_NAME", {}],
    ["/:dyn/something", "ACTION_NAME", {}]
  ];
  const action = { type: "ACTION_NAME", dynamic: "hooray" };
  const { store } = setupTest(routesConfig);
  // when
  const actual = store.pathForAction(action);

  // then
  expect(actual).toEqual("/something/hooray");
});

console.log = console_log;