/*

 * 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 <fnmatch.h>

#include "FindJob.h"

#include "CmdExec.h"

#include "misc.h"

#include "GetFileInfo.h"

#include "url.h"

#include "PatternSet.h"

#include "buffer_std.h"

#define top (*stack.last())

#define stack_ptr (stack.count()-1)

#define super SessionJob

#define orig_session super::session

int FinderJob::Do()

{

   int m=STALL;

   prf_res pres;

   Job *j;

   switch(state)

   {

   case START_INFO:

   {

      if(stack_ptr==-1)

      {

	 ParsedURL u(dir,true);

	 if(u.proto)

	 {

	    session=my_session=FileAccess::New(&u);

	    session->SetPriority(fg?1:0);

	    init_dir=session->GetCwd();

	    Down(u.path?u.path.get():init_dir.path.get());

	 }

      }

      /* If we're not validating, and this is an argument (first-level path),

       * pretend the file exists. */

      if((file_info_need|FileInfo::NAME) == FileInfo::NAME &&

	    !validate_args && stack_ptr == -1)

      {

	 FileSet *fs = new FileSet();

	 fs->Add(new FileInfo(dir));

	 Push(fs);

	 state=LOOP;

	 return MOVED;

      }

      /* The first time we get here (stack_ptr == -1), dir is an actual

       * argument, so it might be a file.  (Every other time, it's guaranteed

       * to be a directory.)  Set show_dirs to true, so it'll end up actually

       * being on the stack, with type information. */

      li=new GetFileInfo(session, dir, stack_ptr == -1);

      /* Prepend for the argument level entry only: */

      if(stack_ptr != -1)

	 li->DontPrependPath();

      int need = file_info_need|FileInfo::NAME;

      /* We only explicitely need the type if we're recursing further. */

      if(stack_ptr+1 < maxdepth)

	 need |= FileInfo::TYPE;

      li->Need(need);

      if(use_cache)

	 li->UseCache();

      state=INFO;

      m=MOVED;

   }

   case INFO:

      if(!li->Done())

	 return m;

      if(li->Error())

      {

	 if(!quiet)

	    eprintf("%s: %s\n",op,li->ErrorText());

	 li=0;

	 errors++;

	 depth_done=true;

	 state=LOOP;

	 return MOVED;

      }

      if(stack_ptr != -1 && li->WasDirectory())

	 Enter(dir);

      Push(li->GetResult());

      top.fset->rewind();

      li=0;

      state=LOOP;

      m=MOVED;

   case LOOP:

      if(stack_ptr==-1 || top.fset->curr()==0)

      {

	 Up();

	 return MOVED;

      }

      session->SetCwd(init_dir);

      session->Chdir(top.path,false);

      // at this point either is true:

      // 1. we just process another file (!depth_done)

      // 2. we just returned from a subdir (depth_done)

      if(depth_first && !depth_done && (maxdepth == -1 || stack_ptr+1 < maxdepth))

      {

	 FileInfo *f=top.fset->curr();

	 if((f->defined&f->TYPE) && f->filetype==f->DIRECTORY)

	 {

	    Down(f->name);

	    return MOVED;

	 }

      }

      state=PROCESSING;

      m=MOVED;

   case PROCESSING:

      pres=ProcessFile(top.path,top.fset->curr());

      if(pres==PRF_LATER)

	 return m;

      depth_done=false;

      switch(pres)

      {

      case(PRF_FATAL):

	 errors++;

	 state=DONE;

	 return MOVED;

      case(PRF_ERR):

	 errors++;

	 break;

      case(PRF_WAIT):

	 state=WAIT;

	 return MOVED;

      case(PRF_OK):

	 break;

      case(PRF_LATER):

	 abort();

      }

   post_WAIT:

      state=LOOP;

      m=MOVED;

      if(stack_ptr==-1)

	 return m;

      if(!depth_first && (maxdepth == -1 || stack_ptr+1 < maxdepth))

      {

	 FileInfo *f=top.fset->curr();

	 if((f->defined&f->TYPE) && f->filetype==f->DIRECTORY)

	 {

	    top.fset->next();

	    Down(f->name);

	    return MOVED;

	 }

      }

      top.fset->next();

      return MOVED;

   case WAIT:

      j=FindDoneAwaitedJob();

      if(!j)

	 return m;

      RemoveWaiting(j);

      Delete(j);

      goto post_WAIT;

   case DONE:

      return m;

   }

   return m;

}

void FinderJob::Up()

{

   if(stack_ptr==-1)

   {

   done:

      state=DONE;

      Finish();

      return;

   }

   /* stack[0] is the dir entry for the argument (ie. ls -d dir), and

    * stack[1] is the contents (ls dir); don't exit for the first. */

   if(stack_ptr)

      Exit();

   stack.chop();

   if(stack_ptr==-1)

      goto done;

   depth_done=true;

   state=LOOP;

}

void FinderJob::Push(FileSet *fset)

{

   const char *old_path=0;

   if(stack_ptr>=0)

   {

      old_path=top.path;

      fset->ExcludeDots(); /* don't need . and .. (except for stack[0]) */

   }

   const char *new_path="";

   if(old_path) // the first path will be empty

      new_path=alloca_strdup(dir_file(old_path,dir));

   /* matching exclusions don't include the path, so they operate

    * on the filename portion only */

   if(exclude)

      fset->Exclude(0, exclude);

   stack.append(new place(new_path,fset));

   /* give a chance to operate on the list as a whole, and

    * possibly sort it */

   ProcessList(fset);

}

void FinderJob::Down(const char *p)

{

#ifdef FIND_DEBUG

   printf("Down(%s)\n",p.get());

#endif

   dir.set(p);

   state=START_INFO;

}

FinderJob::prf_res FinderJob::ProcessFile(const char *d,const FileInfo *f)

{

   return PRF_OK;

}

void FinderJob::Init()

{

   op="find";

   errors=0;

   li=0;

   show_sl=true;

   depth_first=false; // useful for rm -r

   depth_done=false;

   file_info_need=0;

   use_cache=true;

   validate_args=false;

   quiet=false;

   maxdepth=-1;

   exclude=0;

   state=START_INFO;

}

FinderJob::FinderJob(FileAccess *s)

   : SessionJob(s), orig_init_dir(orig_session->GetCwd()),

     session(orig_session), init_dir(session->GetCwd())

{

   Init();

}

void FinderJob::NextDir(const char *d)

{

   if(session!=orig_session)

   {

      session=orig_session;

      init_dir=orig_init_dir;

   }

   session->SetCwd(init_dir);

   Down(d);

}

FinderJob::~FinderJob()

{

}

void FinderJob::ShowRunStatus(const SMTaskRef<StatusLine>& sl)

{

   if(!show_sl)

      return;

   switch(state)

   {

   case INFO:

      sl->Show("%s: %s",dir_file(stack_ptr>=0?top.path.get():0,dir),li->Status());

      break;

   case WAIT:

      Job::ShowRunStatus(sl);

      break;

   default:

      sl->Clear();

      break;

   }

}

xstring& FinderJob::FormatStatus(xstring& s,int v,const char *prefix)

{

   SessionJob::FormatStatus(s,v,prefix);

   switch(state)

   {

   case INFO:

      s.appendf("\t%s: %s\n",dir_file(stack_ptr>=0?top.path.get():0,dir),li->Status());

      break;

   case WAIT:

      break;

   default:

      break;

   }

   return s;

}

void FinderJob::Fg()

{

   super::Fg();

   if(orig_session!=session)

      session->SetPriority(1);

}

void FinderJob::Bg()

{

   if(orig_session!=session)

      session->SetPriority(0);

   super::Bg();

}

// FinderJob_List implementation

// find files and write list to a stream

FinderJob::prf_res FinderJob_List::ProcessFile(const char *d,const FileInfo *fi)

{

   if(buf->Broken())

      return PRF_FATAL;

   if(buf->Error())

   {

      eprintf("%s: %s\n",op,buf->ErrorText());

      return PRF_FATAL;

   }

   if(fg_data==0)

      fg_data=buf->GetFgData(fg);

   if(buf->Size()>0x10000)

      return PRF_LATER;

   xstring path_to_show;

   if(ProcessingURL())

   {

      FileAccess::Path old_cwd=session->GetCwd();

      session->SetCwd(init_dir);

      path_to_show.set(session->GetFileURL(dir_file(d,fi->name)));

      session->SetCwd(old_cwd);

   }

   else

      path_to_show.set(dir_file(d,fi->name));

   if((fi->defined&fi->TYPE) && fi->filetype==fi->DIRECTORY && strcmp(fi->name,"/"))

      path_to_show.append('/');

   if(long_listing) {

      FileInfo n(*fi);

      n.SetName(path_to_show);

      n.MakeLongName();

      buf->Put(n.longname);

   } else {

      buf->Put(path_to_show);

   }

   buf->Put("\n");

   return FinderJob::ProcessFile(d,fi);

}

FinderJob_List::FinderJob_List(FileAccess *s,ArgV *a,FDStream *o)

   : FinderJob(s), args(a), long_listing(false)

{

   if(o)

      buf=new IOBufferFDStream(o,IOBuffer::PUT);

   else

      buf=new IOBuffer_STDOUT(this);

   show_sl = !o || !o->usesfd(1);

   NextDir(a->getcurr());

   ValidateArgs();

}

void FinderJob_List::Finish()

{

   const char *d=args->getnext();

   if(!d) {

      buf->PutEOF();

      return;

   }

   NextDir(d);

}