import R from 'ramda';
 

 function pathSplit(path) {
   return path.split('/');
 }
 

 function mostSpecificRouteMatch(match1, match2) {
 
   if (!match1) {
     return match2;
   }
 

   const paramLength1 = match1.routeParams.length;
   const paramLength2 = match2.routeParams.length;

   let findWildcard = R.compose(R.findIndex.bind(R, isWildcard), pathSplit);

   let result = (paramLength1 > paramLength2) ? match2 : match1;

 
   if (paramLength1 === paramLength2) {
 

     let path1WildcardIdx = findWildcard(match1.path);
     let path2WildcardIdx = findWildcard(match2.path);
 
     result = (path1WildcardIdx !== -1 && path1WildcardIdx < path2WildcardIdx) ? match2 : match1;

   }
 
   if (result === null) {
     throw new Error("routes should have been disambiguated at compile time");
   }
 
   return result;
 }
 
 // do something with routes.
 function matchRoute(loc, matchers) {
 
   const inputPath = loc.pathname;
 
   const buildMatch = (extractedParams, route) => Object.assign({extractedParams}, route);
 

   return R.toPairs(matchers).reduce((match, [path,{type: matcherType, route}]) => {

     const pathMatcher = route.routeMatcher;
     const matchedParams = pathMatcher(inputPath);
 

     if (matchedParams) {

       if (matcherType === 'exact') {

         return buildMatch(matchedParams, route);
       } else {
         return mostSpecificRouteMatch(match, buildMatch(matchedParams, route));
       }

     } else {
       return match;

     }
 

   }, null);

 }
 
 function mostSpecificActionMatch(match1, match2) {
 
   if (!match1) {
     return match2;
   }
 

   let countExtraParams = ({extraParams: obj}) => Object.keys(obj).length;
   return countExtraParams(match1) >= countExtraParams(match2) ? match1 : match2;

 }
 
 // matchers is {action : [routeMatcher]} structure
 function matchAction(action, matchers) {
   // match on params in action vs possible actions if more than 1
   let match = null;
 

   const {type: actionType, ...args} = action;
   const routes = matchers[actionType];

 
   // Specificity:
   // 1. wildcard(s) / no extra param   /route/:id  || /route/me
   // 2. wildcards /  exact extra params match with remaining wildcard
   // 3. no-wildcard / exact extra params match
 
   for (const {type: matcherType, route} of routes) {
     if (matcherType === "exact" && R.equals(route.extraParams, args)) {
       match = Object.assign({extractedParams: {}}, route);
       // case 3
       break; // most specific
     } else if (matcherType === "wildcard") {
       // case 1+2
 
       const unallocatedArgKeys = R.difference(Object.keys(args), Object.keys(route.extraParams));
       // if all keys ^ are equal to all keys in route
       const intersectCount = R.intersection(unallocatedArgKeys, route.routeParams).length;

       const unionCount = R.union(unallocatedArgKeys, route.routeParams).length;

       if (intersectCount === unionCount) {

         const extractedParams = R.pick(unallocatedArgKeys, args);
         match = mostSpecificActionMatch(match, Object.assign({extractedParams}, route));
       }
     }
   }
 
   return match;
 }
 
 function matchesAction(action, matchers) {
   return !!matchers[action.type];
 }
 

 function isWildcard(segment) {
   return segment && segment[0] === ":";
 }

 function extractParams(path) {
   const pathParts = path.split("/");
   let params = [];
 

   for (const part of pathParts.filter(isWildcard)) {
     const name = part.slice(1);

     if (params.indexOf(name) !== -1) {
       throw new Error("duplicate param");

     }

 
     params.push(name);

   }
 
   return params;
 }
 
 function normalizePathParts(path) {
   const rawPathParts = R.split('/', path);
   const normalizedPathParts = R.filter(p => p !== "", rawPathParts);
   return normalizedPathParts;
 }
 
 function makeRoute(path, action, extraParams) {
 
   let type = "exact";
   if (path.indexOf(":") !== -1) {
     type = "wildcard";
   }
 
   const normalizedPathParts = normalizePathParts(path);
 

   const updateWildcard = (wildcards, match, input) => {
     const wildcardName = match.replace(':', '');
     return Object.assign(wildcards, {[wildcardName]: input});

   };

   const routeMatcher = function (inputPath) {

     let result = null;

     const normMatchPath = normalizedPathParts;
     const normInputPath = normalizePathParts(inputPath);
 

     // exact match

     if (R.equals(normalizedPathParts, normInputPath)) {
       return {};
     }
 

     //wildcard match

     const inputLength = normInputPath.length;
     const matchLength = normMatchPath.length;
 

     if (inputLength === matchLength) {
       const f = (acc, [match, input]) => {
         if (acc === null) {
           return null;
         }
 
         if(match === input) {

           return acc;

         } else if (match[0] === ":") {
           return updateWildcard(acc, match, input);
         } else {
           return null;
         }
       };

       result = R.zip(normMatchPath, normInputPath).reduce(f, {});

     }
 

     return result;

   };
 
 
   let routeParams = extractParams(path);
 
   return {
     type,
     route: {
       routeMatcher,
       path,
       action,
       routeParams,
       extraParams
     }

   };

 }
 
 function getRouteByPath(pattern, matchers) {
   return matchers.compiledRouteMatchers[pattern];
 }
 

 function normalizeWildcards(path) {
   let curIdx = 0;
   return path.map((el) => {
     if (isWildcard(el)) {

       return `:wildcard${curIdx}`;

     } else {
       return el;
     }
   });
 }
 
 function routeAlreadyExists(compiledRouteMatchers, path) {

   let result = compiledRouteMatchers.hasOwnProperty(path);

 
   if (!result) {
     const normalizingSplit = R.compose(normalizeWildcards, pathSplit);
     const pathParts = normalizingSplit(path);
 
     for (const otherPath of Object.keys(compiledRouteMatchers)) {
       const otherPathParts = normalizingSplit(otherPath);
       if (R.equals(pathParts, otherPathParts)) {

         throw new Error(`invalid routing configuration — route ${path} overlaps with route ${otherPath}`);

       }
     }
   }
 
   return result;
 }
 

 function compileRoutes(routesConfig) {
   let compiledActionMatchers = {};
   let compiledRouteMatchers = {};
 
   for (let [path, action, extraParams] of routesConfig) {
 
     if(typeof path !== 'string' || typeof action !== 'string') {
       throw new Error("invalid routing configuration - path and action must both be strings");
     }
 
     if (!compiledActionMatchers[action]) {
       compiledActionMatchers[action] = [];
     }
 
     const route = makeRoute(path, action, extraParams);
     compiledActionMatchers[action].push(route);
 

     if (routeAlreadyExists(compiledRouteMatchers, path)) {

       throw new Error("overlapping paths");
     }
 
     compiledRouteMatchers[path] = route;
   }
   return {
     compiledActionMatchers, // { ACTION: [Route] }

     compiledRouteMatchers  // { PATH: Route }
   };

 }
 
 ///////
 
 function constructAction(match) {
   return {type: match.action, ...match.extractedParams, ...match.extraParams};
 }
 
 function constructPath(match) {
   let parts = match.path.split('/');
   let resultParts = [];
 
   for (let part of parts) {
     if (part[0] === ":") {
       const name = part.slice(1);
       const val = match.extractedParams.hasOwnProperty(name)

             ? match.extractedParams[name] : match.extraParams[name];

       resultParts.push(val);
     } else {
       resultParts.push(part);
     }
   }
   return resultParts.join('/');
 }
 
 function createActionDispatcher(routesConfig, window) {
   let {compiledActionMatchers, compiledRouteMatchers} = compileRoutes(routesConfig);
 
   let actionDispatcher = {

     currentLocation: null,
 

     store: null,
     activateDispatcher(store) {
       window.addEventListener('urlchanged', this);
       this.store = store;
     },
     enhanceStore(nextStoreCreator) {
       return (reducer, finalInitialState, enhancer) => {
         let theStore = nextStoreCreator(reducer, finalInitialState, enhancer);
         this.activateDispatcher(theStore);
         return theStore;

       };

     },
     handleEvent(ev) {
 
       if (!this.store) {
         throw new Error("You must call activateDispatcher with redux store as argument");
       }
 
       const location = ev.detail;

       this.receiveLocation(location);
     },
     receiveLocation(location) {

       if (this.currentLocation !== location.pathname) {
         this.currentLocation = location.pathname;
         const match = matchRoute(location, compiledRouteMatchers);
         if(match) {
           const action = constructAction(match);

           this.store.dispatch(action);
         }

       }
     },
     receiveAction(action) {
       let matcher = matchAction(action, compiledActionMatchers);
       if(matcher) {
         let path = constructPath(matcher);
         window.history.pushState({}, '', path);
       }
     },
     handlesAction(action) {
       return matchesAction(action, compiledActionMatchers);
     }
   };
 
   actionDispatcher.enhanceStore = actionDispatcher.enhanceStore.bind(actionDispatcher);
 
   return actionDispatcher;
 }
 
 function buildMiddleware(actionDispatcher) {
   return store => next => action => {
     if (actionDispatcher.handlesAction(action)) {

       actionDispatcher.receiveAction(action, store);

     }
     return next(action);
   };
 }
 
 export default function installBrowserRouter(routesConfig, window) {
 
   const actionDispatcher = createActionDispatcher(routesConfig, window);
 
   const middleware = buildMiddleware(actionDispatcher);
 

   return {middleware, enhancer: actionDispatcher.enhanceStore, init: actionDispatcher.receiveLocation.bind(actionDispatcher, window.location)};

 }