/*
 * lftp - file transfer program
 *
 * Copyright (c) 1996-2012 by Alexander V. Lukyanov (lav@yars.free.net)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <assert.h>
#include "FileAccess.h"
#include "LsCache.h"
#include "plural.h"
#include "misc.h"

int LsCacheEntry::EstimateSize() const
{
   int size=sizeof(*this);
   size+=LsCacheEntryLoc::EstimateSize();
   size+=LsCacheEntryData::EstimateSize();
   return size;
}
LsCacheEntryLoc::LsCacheEntryLoc(const FileAccess *p_loc,const char *a,int m)
   : arg(a), mode(m)
{
   loc=p_loc->Clone();
   loc->Suspend();
}
const char *LsCacheEntryLoc::GetClosure() const
{
   return loc->GetHostName();
}
LsCacheEntryData::LsCacheEntryData(int e,const char *d,int l,const FileSet *fs)
{
   SetData(e,d,l,fs);
}

LsCacheEntry::LsCacheEntry(const FileAccess *p_loc,const char *a,int m,int e,const char *d,int l,const FileSet *fs)
   : LsCacheEntryLoc(p_loc,a,m), LsCacheEntryData(e,d,l,fs)
{
   SetResource(e==FA::OK?"cache:expire":"cache:expire-negative",GetClosure());
}

void LsCacheEntryData::SetData(int e,const char *d,int l,const FileSet *fs)
{
   afset=fs?new FileSet(fs):0;
   data.nset(d,l);
   err_code=e;
}
void LsCacheEntryData::GetData(int *e,const char **d,int *l,const FileSet **fs)
{
   if(d && l)
   {
      *d=data;
      *l=data.length();
   }
   if(fs)
      *fs=afset;
   *e=err_code;
}
bool LsCacheEntryLoc::Matches(const FileAccess *p_loc,const char *a,int m)
{
   return (m==-1 || mode==m) && arg.eq(a) && p_loc->SameLocationAs(loc);
}

ResDecl res_cache_empty_listings("cache:cache-empty-listings","no",ResMgr::BoolValidate,0);
ResDecl res_cache_enable("cache:enable","yes",ResMgr::BoolValidate,0);
ResDecl res_cache_expire("cache:expire","60m",ResMgr::TimeIntervalValidate,0);
ResDecl res_cache_expire_neg("cache:expire-negative","1m",ResMgr::TimeIntervalValidate,0);
ResDecl res_cache_size  ("cache:size","16M",ResMgr::UNumberValidate,ResMgr::NoClosure);

LsCache::LsCache() : Cache(&res_cache_size,&res_cache_enable) {}

void LsCache::Add(const FileAccess *p_loc,const char *a,int m,int e,const char *d,int l,const FileSet *fs)
{
   if(!strcmp(p_loc->GetProto(),"file"))
      return;  // don't cache local objects
   if(l == 0 &&
	 !res_cache_empty_listings.QueryBool(p_loc->GetHostName()))
      return;
   if(e!=FA::OK && e!=FA::NO_FILE && e!=FA::NOT_SUPP)
      return;

   Trim();

   LsCacheEntry *c=Find(p_loc,a,m);
   if(!c)
   {
      if(!IsEnabled(p_loc->GetHostName()))
	 return;
      AddCacheEntry(new LsCacheEntry(p_loc,a,m,e,d,l,fs));
   }
   else
   {
      c->SetData(e,d,l,fs);
   }
}

void LsCache::Add(const FileAccess *p_loc,const char *a,int m,int e,const Buffer *ubuf,const FileSet *fs)
{
   if(!ubuf->IsSaving())
      return;

   const char *cache_buffer;
   int cache_buffer_size;
   if(e)
   {
      cache_buffer=ubuf->ErrorText();
      cache_buffer_size=strlen(cache_buffer)+1;
   }
   else
      ubuf->GetSaved(&cache_buffer,&cache_buffer_size);
   LsCache::Add(p_loc,a,m,e,cache_buffer,cache_buffer_size,fs);
}

LsCacheEntry *LsCache::Find(const FileAccess *p_loc,const char *a,int m)
{
   if(!IsEnabled(p_loc->GetHostName()))
      return 0;

   LsCacheEntry *c;
   for(c=IterateFirst(); c; c=IterateNext())
   {
      if(c->Matches(p_loc,a,m))
	 break;
   }
   if(c && c->Stopped())
   {
      Trim();
      return 0;
   }
   return c;
}

bool LsCache::Find(const FileAccess *p_loc,const char *a,int m,int *e,const char **d,int *l,const FileSet **fs)
{
   LsCacheEntry *c=Find(p_loc,a,m);
   if(!c)
      return false;
   c->GetData(e,d,l,fs);
   return true;
}

const FileSet *LsCache::FindFileSet(const FileAccess *p_loc,const char *a,int m)
{
   LsCacheEntry *c=Find(p_loc,a,m);
   if(!c)
      return 0;
   return c->GetFileSet(c->loc);
}
const FileSet *LsCacheEntryData::GetFileSet(const FileAccess *parser)
{
   if(afset)
      return afset;
   if(err_code!=FA::OK)
      return 0;
   afset=parser->ParseLongList(data, data.length());
   return afset;
}

void LsCache::UpdateFileSet(const FileAccess *p_loc,const char *a,int m,const FileSet *fs)
{
   if(!fs)
      return;
   LsCacheEntry *c=Find(p_loc,a,m);
   if(!c)
      return;
   c->UpdateFileSet(fs);
}

void LsCache::List()
{
   Trim();

   long vol=0;
   for(LsCacheEntry *c=IterateFirst(); c; c=IterateNext())
      vol+=c->EstimateSize();

   printf(plural("%ld $#l#byte|bytes$ cached",vol),vol);

   long sizelimit=res_cache_size.Query(0);
   if(sizelimit<0)
      puts(_(", no size limit"));
   else
      printf(_(", maximum size %ld\n"),sizelimit);
}

void LsCache::Changed(change_mode m,const FileAccess *f,const char *dir)
{
   xstring fdir(dir_file(f->GetCwd(),dir));
   if(m==FILE_CHANGED)
      dirname_modify(fdir);

   LsCacheEntry *c=IterateFirst();
   while(c)
   {
      const FileAccess *sloc=c->loc;
      if(f->SameLocationAs(sloc) || (f->SameSiteAs(sloc)
	       && (m==TREE_CHANGED?
		     !strncmp(fdir,dir_file(sloc->GetCwd(),c->arg),fdir.length())
		   : !strcmp (fdir,dir_file(sloc->GetCwd(),c->arg)))))
	 c=IterateDelete();
      else
	 c=IterateNext();
   }
}

/* Mark a path as a directory or file. (We have other ways of knowing this;
 * this is the most explicit and least expensive.) */
void LsCache::SetDirectory(const FileAccess *p_loc, const char *path, bool dir)
{
   if(!path)
      return;

   FileAccess::Path new_cwd = p_loc->GetCwd();
   new_cwd.Change(path,!dir);
   SMTaskRef<FileAccess> new_p_loc(p_loc->Clone());
   new_p_loc->SetCwd(new_cwd);

   const char *entry = dir? "1":"0";
   LsCache::Add(new_p_loc,"",FileAccess::CHANGE_DIR, dir?FA::OK:FA::NO_FILE, entry, strlen(entry));
}

/* This is a hint function. If file type is really needed, use GetFileInfo
 * with showdir set to true. (GetFileInfo uses this function.)
 * Returns -1 if type is not known, 1 if a directory, 0 if a file. */

int LsCache::IsDirectory(const FileAccess *p_loc,const char *dir_c)
{
   FileAccess::Path new_cwd(p_loc->GetCwd());
   new_cwd.Change(dir_c);
   FileAccessRef new_p_loc(p_loc->Clone());
   new_p_loc->SetCwd(new_cwd);

   int ret = -1;

   /* Cheap tests first:
    *
    * First, we know the path is a directory or not if we have an expicit
    * CHANGE_DIR entry for it. */
   const char *buf_c;
   int bufsiz;
   int e;
   if(Find(new_p_loc, "", FileAccess::CHANGE_DIR, &e, &buf_c,&bufsiz))
   {
      assert(bufsiz==1);
      return (e==FA::OK);
   }

   /* We know the path is a directory if we have a cache entry for it.  This is
    * true regardless of the list type.  (Unless it's a CHANGE_DIR entry; do this
    * test after the CHANGE_DIR check.) */
   if(Find(new_p_loc, "", FA::LONG_LIST, &e, 0,0))
      return(e==FA::OK);
   if(Find(new_p_loc, "", FA::MP_LIST, &e, 0,0))
      return(e==FA::OK);
   if(Find(new_p_loc, "", FA::LIST, &e, 0,0))
      return(e==FA::OK);

   /* We know this is a file or a directory if the dirname is cached and
    * contains the basename. */
   {
      const char *bn=basename_ptr(new_cwd.path);
      bn=alloca_strdup(bn); // save basename

      new_cwd.Change("..");
      new_p_loc->SetCwd(new_cwd);

      const FileSet *fs=FindFileSet(new_p_loc, "", FA::MP_LIST);
      if(!fs)
	 fs=FindFileSet(new_p_loc, "", FA::LONG_LIST);
      if(fs)
      {
	 FileInfo *fi=fs->FindByName(bn);
	 if(fi && (fi->defined&fi->TYPE))
	    return(fi->filetype == fi->DIRECTORY);
      }
   }

   return ret;
}