// Script for calling uprar and other folder clean up tasks

// This is a script for Directory Opus.
// See http://www.gpsoft.com.au/DScripts/redirect.asp?page=scripts for development information.
// 
// Called by Directory Opus to initialize the script
var doCmd = DOpus.NewCommand;
var progress;

function OnInit(initData)
{
  var uid = "0685a7ee-dd5c-4b96-a97d-f55717f5979e";
  var url = "http://resource.dopus.com/viewtopic.php?f=35&t=21696";
  
  if (doCmd.IsSet("$glob:debug")) (DOpus.OutputString("OnInit " + GetScriptEngineInfo()));
  
  initData.name = "Clean Folders";
  initData.desc = "Clean folders."; 
  initData.copyright = "wowbagger";
  initData.version = "1.0"; 
  initData.default_enable = true;
  initData.config_desc = DOpus.NewMap();
 
  /////////////////////////////////////////////////
  // The following options are user configurable via the Configure button under the scripts entry in Prefs
  /////////////////////////////////////////////////
  // Set DEBUG flag below to true in order to enable logging messages to the Opus Output Window
  initData.config.DEBUG = false;
  initData.config_desc("DEBUG") = "Set DEBUG flag to true in order to enable logging messages to the Opus Output Window.";
 
  initData.config.ScanLimit = 1000;
  initData.config_desc("ScanLimit") = "Maximum number of items to process in a folder.";
 
  initData.config.CleanListFolder_FilesToIgnore = "^(thumbs\\.db|desktop\\.ini|folder.*|.*\\.(jpg|jpeg))$";
  initData.config_desc("CleanListFolder_FilesToIgnore") = "When cleaning a list folder, files that match this regexp will be ignored.";
 
  initData.config.CleanItemFolder_FoldersToCollapse = "^((cd|dvd)[0-9])$";
  initData.config_desc("CleanItemFolder_FoldersToCollapse") = "When cleaning an item folder, folders that match this regexp will be collapsed.";
 
  initData.config.rarFiles = ".*\\.rar$"; //".*(?:(?<!\\.part\\d\\d\\d|\\.part\\d\\d|\\.part\\d)\\.rar|\\.part0*1\\.rar)";
  initData.config_desc("rarFiles") = "When cleaning an item folder, files that match this regexp will be unrared.";
  
  initData.config.unrarExePathKey = "unrarexe";
  initData.config_desc("unrarExePathKey") = "global var where path to unrar exe will be stored.";
  
  var cmd = initData.AddCommand();
  cmd.name = "CollapseFolder";
  cmd.method = "onCollapseFolder";
  cmd.desc =  "Move contents of folder to parent, optionally removing folder";
  cmd.label = "Collapse selected folder "
  cmd.template = "REMOVE/O";
  
  var cmd = initData.AddCommand();
  cmd.name = "FilesToFolders";
  cmd.method = "onFilesToFolders";
  cmd.desc =  "Move each file to a folder of the same name excluding extension c:\\test.txt -> c:\\test\\test.txt";
  cmd.label = "Move Files To Folders of the same name"
  
  var cmd = initData.AddCommand();
  cmd.name = "CleanItemFolder";
  cmd.method = "onCleanItemFolder";
  cmd.desc = initData.desc;
  cmd.label = "Clean item folder";

  var cmd = initData.AddCommand();
  cmd.name = "CleanListFolder";
  cmd.method = "onCleanListFolder";
  cmd.desc = initData.desc;
  cmd.label = "Clean list folder";

  var cmd = initData.AddCommand();
  cmd.name = "unrar";
  cmd.method = "onUnrar";
  cmd.desc = "Unrar given file, optionally remove files if unrar was successful. Requires unrar.exe";
  cmd.label = "Unrar given file";
  cmd.template = "REMOVE/O";
 
  return false;
}

//////////
// Main
//////////
function onCleanListFolder(funcData)
{
	LogMessage("onCleanListFolder");
  var doCmd = DOpus.NewCommand;
  progress = doCmd.progress;
  
  progress.bytes = true;
  progress.abort = true;
  progress.full = true;
  progress.pause = true;
  progress.init(funcData.func.sourcetab, "Cleaning list Folder.");
  //SetTitle("Cleaning list folder ("+itemScanCount+"/" + itemTotalCount + ")");
  
  //progress.AddFiles(funcData.func.sourcetab.selected_dirs.count);
  progress.show();
  
  CleanListFolder(funcData.func.sourcetab.path);
  
  progress.hide();
}

function onCleanItemFolder(funcData)
{
  LogMessage("onCleanItemFolder");
  var doCmd = DOpus.NewCommand;
  progress = doCmd.progress;
  progress.abort=true;
  progress.pause=true;
  progress.init(funcData.func.sourcetab, "Cleaning item Folder.");
  
  progress.show();
  
  CleanItemFolder(funcData.func.sourcetab.path);
   
  progress.hide();
}

function onCollapseFolder(funcData)
{
  var remove = funcData.func.args.got_arg.remove ? funcData.func.args.remove : false; 
  LogMessage("onCollapseFolder: " + (remove ? "removing empty folder" : ""));
 
  var objEnum = new Enumerator( funcData.func.sourcetab.selected_dirs);
  
  while (!objEnum.atEnd())
  {
    var file = objEnum.item();
    CollapseFolder(file, remove);
    objEnum.moveNext();    
  }
} 
  
function onFilesToFolders(funcData)
{
  LogMessage("onFilesToFolders");
 
  //For selected files.
  if(funcData.func.sourcetab.stats.selfiles > 0)
  {
    var objEnum = new Enumerator(funcData.func.sourcetab.selected_files);
    while (!objEnum.atEnd())
    {
      var file = objEnum.item();
      FileToFolder(file);
      objEnum.moveNext();    
    }
  }
  else
  {
    //For current folder
    FilesToFolders(funcData.func.sourcetab.path);
  }
}
  
function onUnrar(funcData)
{
  var remove = funcData.func.args.got_arg.remove ? funcData.func.args.remove : false; 
  LogMessage("onUnrar: " + (remove ? "removing rar files" : ""));
 
  //For selected files.
  if(funcData.func.sourcetab.stats.selfiles > 0)
  {
    var objEnum = new Enumerator(funcData.func.sourcetab.selected_files);
    while (!objEnum.atEnd())
    {
      var file = objEnum.item();
      unrar(file, true);
      objEnum.moveNext();    
    }
  }
}
///////////////////
//Functions
///////////////////
function SetProgress(percent)
{
  if(progress)
  {
    if( percent > 100) 
      percent = 100
     
    progress.SetPercentProgress(percent);
  }
}

function SetFromTo(action, currentItem)
{
  if(progress)
  {
    progress.SetFromTo(action, currentItem);
  }
}

function SetProgressStatus(currentFile)
{
  if(progress)
  {
    progress.SetStatus(currentFile);
  }
}

function SetProgressTitle(title)
{
  if(progress)
  {
    progress.SetTitle(title);
  }
}
    
function SetProgressItem(type, name)
{
  if(progress)
  {
    progress.SetType(type + ":");
    progress.SetName(name);
  }
}

function IsDebugEnabled()
{
  return Script.config.DEBUG || doCmd.IsSet("$glob:debug");
}
function LogMessage(message)
{
  if (IsDebugEnabled()) 
  {
    DOpus.OutputString(message)
  }
}
function GetScriptEngineInfo(){
   var s;
   s = ""; // Build string with necessary info.
   s += ScriptEngine() + " Version ";
   s += ScriptEngineMajorVersion() + ".";
   s += ScriptEngineMinorVersion() + ".";
   s += ScriptEngineBuildVersion();
   return(s);
}

//Unrar, demote cd1,cd2,cd3 //del trash files
function CleanItemFolder(folderPath)
{
  LogMessage("CleanItemFolder folder path:" + folderPath);
  SetFromTo("Cleaning item", folderPath);
  SetProgressStatus("Cleaning item:" + folderPath);  
  var fsu = DOpus.FSUtil;
  if(!fsu.Exists(folderPath))
  {
    LogMessage("Cant find folder " + folderPath);
    return;
  }
  
  var regexp_foldersToCollapse = new RegExp(Script.config.CleanItemFolder_FoldersToCollapse, "i");
  var regexp_rarfiles = new RegExp(Script.config.rarFiles, "i");

  var folderItem = fsu.GetItem(folderPath);
  
  var files = fsu.ReadDir(folderPath);
  var itemScanCount = 0;
  do {
    itemScanCount ++;
    var item = files.Next;
    
    if(item.is_dir)
    {
      if(regexp_foldersToCollapse.test(item.name))
      {
        CollapseFolder(item, true);
      }
    }
    
    if(!item.is_dir)
    {
      if(regexp_rarfiles.test(item.name))
      {
        unrar(item, true);
      }
      
      // Nothing to do with files here.
    }
  } while (!files.complete && itemScanCount < Script.config.ScanLimit);  
}

//Cleans a folder that is a list (all children should be a folder).
//Moves files to folder of same name
//Runs CleanItemFolder on each child folder
function CleanListFolder(folderPath)
{
  LogMessage("CleanListFolder folder path:" + folderPath);
  var fsu = DOpus.FSUtil;
  if(!fsu.Exists(folderPath))
  {
    LogMessage("Cant find folder " + folderPath);
    return;
  }
  //Move this to the loop below.
  FilesToFolders(folderPath);
  
  var itemScanCount = 0;
  
  //var files = fsu.ReadDir(folderPath);
  var enumFiles = fsu.ReadDir(folderPath);
  if (enumFiles.error!=0)
  {
    LogMessage("Error reading folder:" + folderPath);
  }
       
  //var enumFiles = new Enumerator( fsu.ReadDir(folderPath) );
  //if(enumFiles.atEnd())
  //{
  //  LogMessage("No files ing list folder children " + enumFiles.count);
  //}
  //while (!enumFiles.atEnd() && itemScanCount < Script.config.ScanLimit )
  var itemTotalCount = 0;
  while (!enumFiles.complete && itemScanCount < Script.config.ScanLimit )
  {
    itemTotalCount ++;
    var item = enumFiles.Next();
  }
  
  //Set total number of files;
  progress.AddFiles(itemTotalCount);
  
  var enumFiles = fsu.ReadDir(folderPath);
  while (!enumFiles.complete && itemScanCount < Script.config.ScanLimit )
  {
    progress.InitFileSize();
    //LogMessage("Processing list folder children ("+itemScanCount+"/" + itemTotalCount + ")");
  
    if(progress && progress.GetAbortState=="a") break;
    
    if((progress && progress.GetAbortState!="p"))
    {
      SetProgressTitle("Cleaning list folder ("+itemScanCount+"/" + itemTotalCount + ")");
      itemScanCount ++;
      
      //var item = enumFiles.moveNext;
      var item = enumFiles.Next();
    
      if(item.is_dir)
      {
         CleanItemFolder(item);
      }
      
      if(!item.is_dir)
      {
        //if not safe list. (non promotable thumb.db...)
        //promote file
      }
      progress.StepBytes(1);
      progress.StepFiles(1);
    }
  }
  
  //  while (!files.complete && itemScanCount < Script.config.ScanLimit);  
  
  delete fsu;
}

function unrar(filePath, removeOriginal)
{
  removeOriginal = typeof removeOriginal !== 'undefined' ? removeOriginal : false;
  LogMessage("unrar " + (removeOriginal ? "removeOriginal=true " : "") + "file=" + filePath);
  
  
  var fso = new ActiveXObject("Scripting.FileSystemObject"); 
  if(!fso.FileExists(filePath))
  {
    LogMessage("Cant find file " + filePath);
    return;
  }
  
  var file = fso.GetFile(filePath);

  SetProgressItem("Unrar", file.name);
  var unrarPath = getResourcePathFromGlobalVar("Unrar", "Unrar.exe", Script.config.unrarExePathKey, false);
  if(!fso.FileExists(unrarPath))
  {
    LogMessage("Cant find rar.exe  " + unrarPath);
    return;
  }
  
  var unrarCommand = "CMD /S /C \" \"" + unrarPath + "\" x -y \"" + filePath + "\" \"" + file.ParentFolder + "\" \"";
  LogMessage("unrar Command:" + unrarCommand); 
  
  var objShell = new ActiveXObject("WScript.Shell");
  var objExec = objShell.Exec(unrarCommand);
  var strLine;
  var stdout;
  var rarprogress = 0;
  progress.SetFileSize(100);
  
  var regexpPercentage = /(\d\d)%/g;
  
  while (!objExec.StdOut.AtEndOfStream)
  { 
    strText = objExec.StdOut.ReadLine();
    if(regexpPercentage.test(strText))
    {
      var match = regexpPercentage.exec(strText);
      while (match != null)
      {
        rarprogress =  match[1];
        match = regexpPercentage.exec(strText);
      }
    }
    
    LogMessage("StdOut("+rarprogress +"):" + strText ); 
    stdout = stdout + strText + "\r\n";
    progress.SetBytesProgress(rarprogress);
  }
 
  if(objExec.Status == 1 && removeOriginal)
  {
    var regexp_allok = /^All OK$/;
  
    //var stdout = objExec.StdOut.ReadAll();
    var lines = stdout.split(/\r\n|\r|\n/g);
    LogMessage("StdOut:" + stdout + "lines: "+ lines.length); 
    var extractOk = false;
    for (i = 0; i < lines.length; i++) {
      if(regexp_allok.test(lines[i]))
      {
        extractOk = true;
      }
    }
    
    if(extractOk)
    {
      var regexp_rarFile = /^Extracting\sfrom\s(.*)$/;
      for (i = 0; i < lines.length; i++) {
        if(regexp_rarFile.test(lines[i]))
        {
          var matches = regexp_rarFile.exec(lines[i]);
          if(fso.FileExists(matches[1]))
          {
            fso.DeleteFile(matches[1], true);
            //SetProgressItem("Unrar", file.name);
          }
        }
      }
    }
    else
    {
      LogMessage("did not find ALL OK Status:" + objExec.Status); 
    }
  }
  else
  {
    LogMessage("unrar Status:" + objExec.Status); 
  }
}

//Use Dos which does not support unc paths
function FilesToFoldersDos(folderPath)
{
  LogMessage("FilesToFoldersDos folder path:" + folderPath);
  
  var fsu = DOpus.FSUtil;
  var cmd = DOpus.NewCommand;
  
  if(!fsu.Exists(folderPath))
  {
    LogMessage("Cant find folder " + folderPath);
    return;
  }
  
  var folder = fsu.GetItem(folderPath);
  if(!folder.is_dir)
  {
    LogMessage("Not a folder " + folderPath);
    return;
  }
  
  //TODO: this has a problem where if folder path is invalid it defaults to c:\windows\system32.
  cmd.SetSource(folderPath); 
  cmd.SetType("msdos");
  cmd.SetModifier("runmode", "hide");
  cmd.AddLine("@echo off");
  cmd.AddLine("for %%a in (*.*) do (");
  cmd.AddLine("md \"%%~na\" 2>nul");
  cmd.AddLine("move \"%%a\" \"%%~na\"");
  cmd.AddLine(")");
  cmd.Run();
  
  delete fsu;
  delete cmd;
}

//All child folders will become grand child in a folder of the child's name
function FilesToFolders(folderPath)
{
  LogMessage("FilesToFolders folder path:" + folderPath);
  
  var fsu = DOpus.FSUtil;
  
  if(!fsu.Exists(folderPath))
  {
    LogMessage("Cant find folder " + folderPath);
    return;
  }
  
  var folder = fsu.GetItem(folderPath);
  if(!folder.is_dir)
  {
    LogMessage("Not a folder " + folderPath);
    return;
  }

  var foldersToCollapse = new RegExp(Script.config.CleanListFolder_FilesToIgnore, "i");
 
  var files = fsu.ReadDir(folderPath);
  var itemScanCount = 0;
  do {
    itemScanCount ++;
    //SetProgressStatus("Moving child files to Folders. " + itemScanCount + " / " + files.count);
    var item = files.Next;
    if(!item.is_dir && !foldersToCollapse.test(item.name))
    {
      FileToFolder(item);
    }
  } while (!files.complete && itemScanCount < Script.config.ScanLimit);  
}

function FileToFolder(filePath)
{
  LogMessage("FileToFolder file:" + filePath);
  
  var fsu = DOpus.FSUtil;
  
  if(!fsu.Exists(filePath))
  {
    LogMessage("Cant find file " + filePath);
    return;
  }
  
  var file = fsu.GetItem(filePath);
  if(file.is_dir)
  {
    LogMessage("Not a file " + filePath);
    return;
  }
  
  var targetFolder = file.path + "\\" + file.name_stem;
  var targetFile = targetFolder + "\\" + file.name;
 
  var fso = new ActiveXObject("Scripting.FileSystemObject");
  if(!fsu.Exists(targetFolder))
  {
    //LogMessage("Creating folder:" + targetFolder);
    fso.CreateFolder(targetFolder);
  }
  
  //LogMessage("moving file:" + targetFile);
  fso.MoveFile(filePath, targetFile);
}

function CollapseFolder(folderPath, removeEmptyFolder)
{
  removeEmptyFolder = typeof removeEmptyFolder !== 'undefined' ? removeEmptyFolder : false;
  LogMessage("CollapseFolder " + (removeEmptyFolder ? "removing" : "") + " folder path:" + folderPath);
  
  var fsu = DOpus.FSUtil;
  var cmd = DOpus.NewCommand;
  
  if(!fsu.Exists(folderPath))
  {
    LogMessage("Cant find folder " + folderPath);
    return;
  }
  
  var folder = fsu.GetItem(folderPath);
  if(!folder.is_dir)
  {
    LogMessage("Not a folder " + folderPath);
    return;
  }
  
  cmd.SetSource(folderPath); 
  cmd.SetModifier("runmode", "hide");
  cmd.RunCommand("Copy MOVE * TO ..");
  delete cmd;
  if(removeEmptyFolder)
  {
    LogMessage("checking folder for removal:" + folderPath);
    var childItems = fsu.ReadDir(folderPath);
    if(childItems.Complete)
    {
      var cmd2 = DOpus.NewCommand;
 
      LogMessage("removing empty folder:" + folderPath);
      cmd2.SetType("msdos");
      cmd2.SetModifier("runmode", "hide");
      cmd2.RunCommand("rmdir \"" + folderPath + "\"");
      delete cmd2;
    }
  }
  delete fsu;
}

function getResourcePathFromGlobalVar(name, filename, varKey, forceUserRequest)
{
  var doFsu = DOpus.FSUtil;
  var doCmd = DOpus.NewCommand;
  var doVars = DOpus.vars;

  var resourcePath;
  if(!forceUserRequest && doVars.Exists(varKey))
  {
    resourcePath = doVars.Get(varKey);
  }

  if(!resourcePath || !doFsu.Exists(doFsu.Resolve(resourcePath)))
  {
    var dlg = DOpus.Dlg;
    var dlgResult = dlg.Open("Please locate the executable '" +filename + "' for application " + name, doFsu.Resolve("/homeroot"), DOpus.Listers(0));  
    if(dlgResult && dlgResult.result)
    {
      resourcePath = doFsu.Resolve(dlgResult);
      doVars(varKey) = resourcePath;
      doVars(varKey).persist = true;
    }
  }

  DOpus.OutputString("path " + varKey + " resourcePath " + resourcePath);
  
  if(!resourcePath || !doFsu.Exists(doFsu.Resolve(resourcePath)))
  {
    var dlg = DOpus.Dlg;
    dlg.title = name + " not found";
    dlg.message = "Can't find file\n Path:" + resourcePath ;       
    dlg.buttons = "OK";       
    dlg.icon = "error";
    dlg.Show();
    doVars(varKey).Delete();
  }
  else
  {
    return doFsu.Resolve(resourcePath);
  }
}
//MD5 = "a9bbe754b6b5d51486b0c72fd7aa4bde"; DATE = "2015.04.11 - 16:01:57"