import * as 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;

   const findWildcard = R.compose(

     R.findIndex(isWildcard),

     pathSplit
   );

   let result = paramLength1 > paramLength2 ? match2 : match1;

 
   if (paramLength1 === paramLength2) {

     const path1WildcardIdx = findWildcard(match1.path);
     const 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) => ({ extractedParams, ...route });

   return R.reduce(

     (match, [_, { type: matcherType, route }]) => {

       const { pathMatcher } = route;

       const matchedParams = pathMatcher(inputPath);

       if (matchedParams) {

         return matcherType === 'exact'
           ? buildMatch(matchedParams, route)
           : mostSpecificRouteMatch(match, buildMatch(matchedParams, route));

       } else {

         return match;

       }

     },

     null,
     R.toPairs(matchers)

   );

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

   const countExtraParams = ({ extraParams: obj }) => R.keys(obj).length;

   return countExtraParams(match1) >= countExtraParams(match2) ? match1 : match2;

 }
 

 // matchers is {action : [pathMatcher]} 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)) {
       // case 3

       match = { extractedParams: {}, ...route};

       break; // most specific
     } else if (matcherType === "wildcard") {
       // case 1+2
 

       const unallocatedArgKeys = R.difference(

         R.keys(args),
         R.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, { 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("/");
 

   const params = R.compose(
     R.map(x => x.substr(1)),
     R.filter(isWildcard)
   )(pathParts);

   if(R.uniq(params).length !== params.length) {
     throw new Error("duplicate param");

   }

   return params;
 }
 
 function normalizePathParts(path) {

   const splitAndFilterEmpty = R.compose(
     R.filter(p => p !== ""),
     R.split('/')

   );
 
   return splitAndFilterEmpty(path);

 }
 
 function makeRoute(path, action, extraParams) {

   const type = (R.includes(':', path) ? 'wildcard': 'exact');

 
   const normalizedPathParts = normalizePathParts(path);
 

   const pathMatcher = 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) {

       result = R.reduce((extractedValues, [match, input]) => {
         if (extractedValues === null) {

           return null;
         }
 

         if (match === input) {

           return extractedValues;
         } else if (R.startsWith(":", match)) {
           const wildcardName = R.replace(':', '', match);
           return {...extractedValues, [wildcardName]: input};

         } else {
           return null;
         }

       }, {}, R.zip(normMatchPath, normInputPath));

     }
 

     return result;

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

       pathMatcher,

       path,
       action,
       routeParams,
       extraParams
     }

   };

 }
 

 function normalizeWildcards(path) {
   let curIdx = 0;

   //todo curIdx doesn't increment

   return path.map(el => {

     if (isWildcard(el)) {

       return `:wildcard${curIdx}`;

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

   let result = Object.prototype.hasOwnProperty.call(compiledRouteMatchers, path);

 
   if (!result) {

     const normalizingSplit = R.compose(
       normalizeWildcards,
       pathSplit
     );

     const pathParts = normalizingSplit(path);
 

     for (const otherPath of R.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) {

   const compiledActionMatchers = {};
   const 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) {

   const parts = match.path.split("/");
   const resultParts = [];

   for (const part of parts) {

     if (part[0] === ":") {
       const name = part.slice(1);

       const val = Object.prototype.hasOwnProperty.call(match.extractedParams, name)

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

       resultParts.push(val);
     } else {
       resultParts.push(part);
     }
   }

   return resultParts.join("/");

 }
 
 function createActionDispatcher(routesConfig, window) {

   const { compiledActionMatchers, compiledRouteMatchers } = compileRoutes(

     routesConfig
   );

   function pathForAction(action) {
     const match = matchAction(action, compiledActionMatchers);
     return match ? constructPath(match) : null;
   }
 

   function actionForLocation(location) {
     const match = matchRoute(location, compiledRouteMatchers);
     return match ? constructAction(match) : null;
   }
 

   let actionListeners = [];
   let currentPath = null;

   function ifPathChanged(newPath, cb) {
     if (currentPath !== newPath) {
       currentPath = newPath;
       cb();
     }
   }

   const actionDispatcher = {

     pathForAction,

     //hook for everything to get action on route change
     addActionListener(cb) {
       actionListeners.push(cb);
       return () => {
         const index = R.findIndex(x => x === cb, actionListeners);
         actionListeners = R.remove(index, 1, actionListeners);

       }

     },

     //needed for window event listener
     handleEvent(ev) {

       const location = ev.detail;

       this.receiveLocation(location);
     },

     receiveLocation(location) {

       ifPathChanged(location.pathname, () => {

         const action = actionForLocation(location);
 
         if (action) {

           actionListeners.forEach(cb => cb(action));

         }

       });

     },

     // can this be simplified to get rid of fundamental action model?

     receiveAction(action, fireCallbacks = false) {

       const newPath = matchesAction(action, compiledActionMatchers)
                     ? pathForAction(action)
                     : null;

       if (newPath) {
         ifPathChanged(newPath, () => {
           window.history.pushState({}, "", newPath);

           if(fireCallbacks) {
             actionListeners.forEach(cb => cb(action));
           }

         });

       }
     },

   };
 

   window.addEventListener("urlchanged", actionDispatcher);
 

   return actionDispatcher;
 }
 
 

 
 export {createActionDispatcher};