var path = require('path');
var System = require('./system');
var logger = require('./logger');
var Cache = require('./cache');
var promises = require('./promises');

// Constants
var ICON_REALPATH_REGEX = /\..+$/;
var ICON_THEMES_ROOTDIR = '/usr/share/icons';
var PIXMAPS_ICONS_ROOTDIR = '/usr/share/pixmaps';

/**
 * Find and load all the desktop files in the subdirectories of given dirs
 *
 * @param Array[String] rootDirs
 * @return Promise
 */
exports.loadAllDesktopFiles = function(rootDirs) {

  return exports.findAllDesktopFiles(rootDirs)
    .then(function(filePaths) {

      return promises.seq(filePaths, function(path) {
          return exports.loadDesktopFile(path);
        })
        .then(function(contents) {
          return contents.map(function(content, i) {
            return { content: content, path: filePaths[i] };
          });
        })
      ;

    })
  ;

};

/**
 * Find all the desktop files in the subdirectories of given dirs
 *
 * @param Array[String] baseDirs
 * @return Promise
 */
exports.findAllDesktopFiles = function(baseDirs) {

  if(!Array.isArray(baseDirs)) {
    baseDirs = [baseDirs];
  }

  return promises.seq(baseDirs, function(baseDir) {
      return System.findFiles('**/*.desktop', {cwd: baseDir, realpath: true});
    })
    .then(function(apps) {
      return uniq(flatten(apps));
    })
  ;

};

/**
 * Load a .desktop file ans return its parsed content
 *
 * @param string filePath
 * @return Promise
 */
exports.loadDesktopFile = function(filePath) {
  return System.loadINIFile(filePath);
};

var iconCache = new Cache();

/**
 * Find the absolute path of a desktop icon
 *
 * @param string iconPath
 * @return Promise
 */
exports.findIcon = function(iconName, themeName, size, themeIgnore) {

  var cachedIcon = iconCache.get([iconName, themeName, size]);

  if(cachedIcon) {
    logger.debug('Icon %s:%s:%s found in cache !', iconName, themeName, size);
    return Promise.resolve(cachedIcon);
  }

  themeIgnore = themeIgnore || [];
  if(themeIgnore.indexOf(themeIgnore) !== -1) {
    logger.debug('Theme %s already processed, ignoring...', themeName);
    return Promise.resolve(null);
  }
  themeIgnore.push(themeName);

  logger.debug('Searching icon %s:%s:%s...', iconName, themeName, size);

  if( ICON_REALPATH_REGEX.test(iconName) ) {
    return Promise.resolve(iconName);
  }

  if(!themeName) {
    return exports.findIconThemes()
      .then(function(themes) {
        themeIgnore = themeIgnore || [];
        return promises.seq(themes, function(theme) {
            return exports.findIcon(iconName, theme, size, themeIgnore);
          })
          .then(exports._selectBestIcon)
        ;
      })
      .then(_cacheIcon)
    ;
  }

  return exports.findClosestSizeIcon(iconName, themeName, size)
    .then(function(foundIcon) {

      if(foundIcon) return foundIcon;

      logger.debug('No icon found. Search in parents...');

      return exports.findParentsThemeIcon(iconName, themeName, size, themeIgnore)
        .then(function(iconPath) {

          if(iconPath) return iconPath;

          return exports.findPixmapsIcon(iconName);

        })
      ;

    })
    .then(_cacheIcon)
  ;


  function _cacheIcon(iconPath) {
    iconCache.set([iconName, themeName, size], iconPath);
    return iconPath;
  }

};

exports.findParentsThemeIcon = function(iconName, themeName, size, themeIgnore) {

  return exports.themeIndexExists(themeName)
    .then(function(exists) {

      if(!exists) return null;

      return exports.loadThemeIndex(themeName)
        .then(function(themeIndex) {

          if(!themeIndex || !themeIndex['Icon Theme'].Inherits) return;

          var parents = themeIndex['Icon Theme'].Inherits.split(',');

          logger.debug('Found parents', {parents: parents});

          return promises.seq(parents, function(themeName) {
              return exports.findIcon(iconName, themeName, size, themeIgnore);
            })
            .then(exports._selectBestIcon)
          ;

        })
      ;

    })
  ;

};

exports.findClosestSizeIcon = function(iconName, themeName, size) {

  var themePath = path.join(ICON_THEMES_ROOTDIR, themeName);

  var extPattern = '{svg,png}';
  var filePattern = themeName+'/*/*/'+iconName+'.'+extPattern;

  logger.debug('File pattern %s', filePattern);

  return System.findFiles(filePattern, {cwd: ICON_THEMES_ROOTDIR})
    .then(function(iconFiles) {

      logger.debug('Found files', {files: iconFiles});

      var scalableIcon = iconFiles.reduce(function(scalableIcon, iconPath) {
        if(iconPath.indexOf('scalable') !== -1) {
          logger.debug('Found scalable icon %s', iconPath);
          scalableIcon = iconPath;
        }
        return scalableIcon;
      }, null);

      if(scalableIcon) return scalableIcon;

      if(!size) {
        size = Math.max.apply(Math, clean(iconFiles.map(sizeFromPath)));
      }

      var closestIcon = iconFiles.reduce(function(foundIcon, iconPath) {
        var foundSize = sizeFromPath(iconPath);
        if( foundSize && Math.abs(foundSize - size) < Math.abs(foundIcon.size - size) ) {
          foundIcon.path = iconPath;
          foundIcon.size = foundSize;
        }
        return foundIcon;
      }, {path: null, size: null});

      return closestIcon.path;

    })
    .then(function(iconPath) {
      logger.debug('Closest icon', iconPath);
      return iconPath ? path.join(ICON_THEMES_ROOTDIR, iconPath) : null;
    })
  ;

  function sizeFromPath(iconPath) {
    var simpleSizeRegex = /\/(\d+)\//;
    var matches = simpleSizeRegex.exec(iconPath);
    if(matches && matches[1]) return +matches[1];
    var doubleSizeRegex = /\/(\d+)x\d+\//;
    matches = doubleSizeRegex.exec(iconPath);
    if(matches && matches[1]) return +matches[1];
  }

};

exports.findPixmapsIcon = function(iconName) {
  var filePattern = iconName+'.{svg,png}';
  logger.debug('Looking for pixmap icon %s', filePattern);
  return System.findFiles(filePattern, {cwd: PIXMAPS_ICONS_ROOTDIR})
    .then(function(iconPaths) {
      iconPaths = iconPaths.map(function(iconPath) {
        return path.join(PIXMAPS_ICONS_ROOTDIR, iconPath);
      });
      return exports._selectBestIcon(iconPaths);
    })
  ;
};

exports.findIconThemes = function() {
  return System.findFiles('*/', {cwd: ICON_THEMES_ROOTDIR, realpath: true})
    .then(function(files) {
      return files.map(function(f) {
        return path.basename(f);
      });
    })
  ;
};

exports.loadThemeIndex = function(themeName) {
  var themeIndexPath = path.join(ICON_THEMES_ROOTDIR, themeName, 'index.theme');
  return System.loadINIFile(themeIndexPath);
};

exports.themeIndexExists = function(themeName) {
  var themeIndexPath = path.join(ICON_THEMES_ROOTDIR, themeName, 'index.theme');
  return System.exists(themeIndexPath);
};

exports._selectBestIcon = function(iconPaths) {
  var iconSelection = iconPaths.reduce(function(iconSelection, iconPath) {
    if(iconPath) {
      var key = iconPath.indexOf('scalable') !== -1 ? 'scalable' : 'bitmap';
      iconSelection[key] = iconPath;
    }
    return iconSelection;
  }, {scalable: null, bitmap: null});
  logger.debug('Icon selection', iconSelection);
  return iconSelection.scalable || iconSelection.bitmap;
};

// Array helpers

function clean(arr) {
  return arr.filter(function(item) {
    return item !== null && item !== undefined;
  });
}

function flatten(arr) {
  return arr.reduce(function(result, item) {
    result = result.concat.apply(result, Array.isArray(item) ? flatten(item) : [item]);
    return result;
  }, []);
}

function uniq(arr) {
  return arr.reduce(function(result, item) {
    if(result.indexOf(item) === -1) {
      result.push(item);
    }
    return result;
  }, []);
}