import {applyMiddleware, createStore, compose} from 'redux';
 
 import installBrowserRouter from './action-router';

 import addChangeUrlEvent from './change-url-event.js';
 import addMissingHistoryEvents from './history-events.js';

 
 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') {

   const window = {

     location: createLocation(path),

     history: {
       pushState: jest.fn(),
       replaceState: jest.fn()
     }
   };
 
   const map = {};
 
   window.addEventListener = jest.fn((event, cb) => {
     map[event] = cb;
   });
 
   window.dispatchEvent = jest.fn(ev => {
     const evName = ev.type;
     if(map[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 {middleware, enhancer, init} = installBrowserRouter(routesConfig, window);
   const reduce = jest.fn();

   const store = createStore(
     reduce,
     compose(
       enhancer,
       applyMiddleware(
         middleware)));

   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 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'}]);
 
 });