// DOpus Addin: ColFolderDate
// Add columns for newest/oldest filedate in subfolder, with exclusion filtering

// Columns:
// Newest (Create), Oldest (Create), Newest (Modified), Oldest (Modified)

/* exported OnInit,OnAddColumns,OnAddCommands,OnScriptConfigChange,OnFolderDate,OnFDInvertRecursive */

///// LOGGING
// If true, turn on logging.
var gbUseLogging=false;
// If enabled, outputs verbose logging.
var gbUseVerboseLogging=false;

var gvExclusionFilter=null;
var FDColumns=["NewestCreateDate","OldestCreateDate","NewestModifyDate","OldestModifyDate","DaysAgoC","DaysAgoM"];

// Called by Directory Opus to initialize the script
function OnInit(initData){
  initData.name = "ColFolderDate";
  initData.group = "Columns";
  initData.desc = "Add columns for newest/oldest filedate in subfolder, with exclusion filtering. Columns: NewestCreateDate, OldestCreateDate, NewestModifyDate, OldestModifyDate";
  initData.copyright = "myarmor";
  initData.version="0.3";
  initData.default_enable=true;
  initData.config.exclusionFilter=DOpus.Create.Vector('thumbs.db','desktop.ini');
  initData.config.displayForAll=false;
  initData.config.recursive=false;
  initData.config_desc=DOpus.Create.Map('exclusionFilter','Filespecs to exclude from date comparisons','displayForAll',"Display original date if we don't have anything else",'recursive','Determine dates based on files in subfolders too');
}

// Write text to output if gbUseLogging is true.
// If verbose is true, only write if also gbUseVerboseLogging is true.
function Log(s,verbose){
  if (gbUseLogging){
    if ((!verbose)||(gbUseVerboseLogging && verbose)){
      DOpus.Output(s);
    }
  }
}
function InArray(col,arr){
  for (var i=0;i<arr.length;i++){
    if (col==arr[i]){
      return true;
    }
  }
}

function RefreshAllColumns(){
  for (var j=0;j<FDColumns.length;j++){
    Script.RefreshColumn(FDColumns[j]);
  }
}

function AddBaseCol(initData,name,label,recursive){
  var col;
  col=initData.AddColumn();
  col.name = name;
  col.label = label;
  Log('Adding column: Name='+col.name+': Label="'+col.label+'".',true);
  col.method = "OnFolderDate";
  col.autogroup= true;
  col.autorefresh=true;
  col.justify = "right";
  col.multicol=true;
  return col;
}

function AddFolderDateCol(initData,name,label,recursive){
  var col=AddBaseCol(initData,name,label,recursive);
  col.type='datetime';
}

function OnAddColumns(addColData){
  var recursive=Script.config.recursive;
  AddFolderDateCol(addColData,FDColumns[0],"Newest (Create)",recursive);
  AddFolderDateCol(addColData,FDColumns[1],"Oldest (Create)",recursive);
  AddFolderDateCol(addColData,FDColumns[2],"Newest (Modified)",recursive);
  AddFolderDateCol(addColData,FDColumns[3],"Oldest (Modified)",recursive);
  AddBaseCol(addColData,FDColumns[4],"Days Ago (Create)",recursive);
  AddBaseCol(addColData,FDColumns[5],"Days Ago (Modified)",recursive);

}

function OnAddCommands(addCmdData){
  var cmd;
// Call the addCmdData.AddCommand method once for each command you wish to add.
  cmd = addCmdData.AddCommand();
  cmd.name = "FDInvertRecursive";
  cmd.method = "OnFDInvertRecursive";
  cmd.desc = "Invert FolderDate's recursiveness";
  cmd.label = "FDInvertRecursive";
  cmd.template = "";
}

function OnScriptConfigChange(configChangeData){
  RefreshAllColumns();
}
function isAllowed(item){
  if (!gvExclusionFilter){
    return true;
  }
  var len;
  var objWild=DOpus.FSutil.NewWild();
  len=gvExclusionFilter.count;
  if (!len){
    return true;
  }
  for (var i=0;i<len;i++){
    if (objWild.Parse(gvExclusionFilter(i),'f') && objWild.Match(item.name)){
      Log('Exclude: '+item.name);
      return false;
    }
  }
  if (gbUseVerboseLogging){
    Log('Allow: '+item.name,true);
  }
  return true;
}

// Compare items, and return the one that matches criteria.
// - If createmodify is true we want create, otherwise we want modify
// - If oldnew is true we want old, otherwise we want new
function DCompare(a,b,createmodify,oldnew){
  if (!b){
    // If we don't have anything to compare to, return 'a'.
    return a;
  }
  if(!a){
    return null; //Exit if 'a' is null.
  }
  var adate;
  var bdate;
  if (createmodify){
    adate=a.create;
    bdate=b.create;
  } else{
    adate=a.modify;
    bdate=b.modify;
  }
  if (oldnew){
    if (adate.Compare(bdate)<=0){
      return a;
    } else {
      return b;
    }
  } else {
    if (adate.Compare(bdate)>=0){
      return a;
    } else {
      return b;
    }
  }
}

// var months=[31,28,31,30,31,30,31,31,30,31,30,31];
// days_between from http://stackoverflow.com/questions/2627473/how-to-calculate-the-number-of-days-between-two-dates-using-javascript
function days_between(date1, date2){
  // The number of milliseconds in one day
  var ONE_DAY = 1000 * 60 * 60 * 24;

  // Convert both dates to milliseconds
  var date1_ms = date1.getTime();
  var date2_ms = date2.getTime();

  // Calculate the difference in milliseconds
  var difference_ms = Math.abs(date1_ms - date2_ms);

  // Convert back to days and return
  return Math.round(difference_ms/ONE_DAY);
}

function ToValueStr(d){
  switch(d){
    case 0: return 'Today';
    case 1: return 'Yesterday';
    default: return d+' days ago';
  }
}

function DaysAgo(adate){
  return days_between(new Date(),new Date(adate));
}


function ScanFolder(path,filterFunc,recurse){
  var folderEnum;
  var curitm;
  var dOldestCreate;
  var dOldestModify;
  var dNewestCreate;
  var dNewestModify;
  var DaysAgoM;
  var DaysAgoC;
  var nw=new Date();
  folderEnum=DOpus.FSUtil.ReadDir(path,recurse);
  if (folderEnum.error){
    if (folderEnum.error!=18){ //Log it if it doesn't match "No more files".
      Log('ERROR: '+folderEnum.error+' Path: '+path);
    }
    return null;
  }
  if (!folderEnum.complete){
    while (!folderEnum.complete){
      curitm=folderEnum.Next();
      if ((!curitm.is_dir) && (filterFunc(curitm,gvExclusionFilter))){
        // Make all comparisons
        dOldestCreate=DCompare(curitm,dOldestCreate,true,true);
        dOldestModify=DCompare(curitm,dOldestModify,false,true);
        dNewestCreate=DCompare(curitm,dNewestCreate,true,false);
        dNewestModify=DCompare(curitm,dNewestModify,false,false);
        DaysAgoM=days_between(nw,new Date(curitm.modify));
        DaysAgoC=days_between(nw,new Date(curitm.create));
      }
    }
    folderEnum.Close();
  }
  //if dNewestModify is non-null then we can assume that we have data, otherwise we don't.
  if (dNewestModify){
    return {oldcreate:dOldestCreate.create,oldmodify:dOldestModify.modify,newcreate:dNewestCreate.create,newmodify:dNewestModify.modify,daysagocstr:ToValueStr(DaysAgoC),daysagomstr:ToValueStr(DaysAgoM),daysagoc:DaysAgoC,daysagom:DaysAgoM};
  } else {
    return null;
  }
}

function SetSortValue(scriptColData,colname,value){
  scriptColData.columns(colname).sort=value;
}

function SetColumnValues(scriptColData,columnArr,columnValues){
  var bValueArray=columnValues instanceof Array;
  for (var i=0;i<columnArr.length;i++){
    if (bValueArray){
      scriptColData.columns(columnArr[i]).value=columnValues[i];
    } else{
      scriptColData.columns(columnArr[i]).value=columnValues;
    }
  }
}

function CommonFolderDate(scriptColData,columnArr,recursive){
  if (!InArray(scriptColData.col,columnArr)){
    return;
  }
  var daysagoc,daysagom;

  if (scriptColData.item.is_dir) {
    gvExclusionFilter=Script.config.exclusionFilter;
    var item=ScanFolder(scriptColData.item.realpath,isAllowed,recursive);
    if (item){
      SetColumnValues(scriptColData,columnArr,[item.newcreate,item.oldcreate,item.newmodify,item.oldmodify,item.daysagocstr,item.daysagomstr]);
      SetSortValue(scriptColData,FDColumns[4],item.daysagoc);
      SetSortValue(scriptColData,FDColumns[5],item.daysagom);
    } else if (Script.config.displayForAll){
      daysagoc=DaysAgo(scriptColData.item.create);
      daysagom=DaysAgo(scriptColData.item.modify);
      SetColumnValues(scriptColData,columnArr,[scriptColData.item.create,scriptColData.item.create,scriptColData.item.modify,scriptColData.item.modify,ToValueStr(daysagoc),ToValueStr(daysagom)]);
      SetSortValue(scriptColData,FDColumns[4],daysagoc);
      SetSortValue(scriptColData,FDColumns[5],daysagom);
    }
  } else if (Script.config.displayForAll){
    daysagoc=DaysAgo(scriptColData.item.create);
    daysagom=DaysAgo(scriptColData.item.modify);
    SetColumnValues(scriptColData,columnArr,[scriptColData.item.create,scriptColData.item.create,scriptColData.item.modify,scriptColData.item.modify,ToValueStr(daysagoc),ToValueStr(daysagom)]);
    SetSortValue(scriptColData,FDColumns[4],daysagoc);
    SetSortValue(scriptColData,FDColumns[5],daysagom);
  }
}

// Implement the FDInvertRecursive command
function OnFDInvertRecursive(scriptCommandData){
  var recursive;
  if (scriptCommandData.func.sourcetab.vars.Exists('FolderDateInvertRecursive')){
    scriptCommandData.func.sourcetab.vars.Delete('FolderDateInvertRecursive');
  } else {
    recursive=!Script.config.recursive;
    scriptCommandData.func.sourcetab.vars.Set('FolderDateInvertRecursive',recursive);
  }
  scriptCommandData.func.command.deselect=false;
  scriptCommandData.func.command.RunCommand('GO NOSCRIPT REFRESH=SOURCE');
}

function OnFolderDate(scriptColData){
  var recursive;
  if (scriptColData.tab.vars.Exists('FolderDateInvertRecursive')){
    recursive=scriptColData.tab.vars.Get('FolderDateInvertRecursive');
  } else {
    recursive=Script.config.recursive;
  }
  CommonFolderDate(scriptColData,FDColumns,recursive);
}