/*

Directory Opus 4
Original GPL release version 4.12
Copyright 1993-2000 Jonathan Potter

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 2
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, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

All users of Directory Opus 4 (including versions distributed
under the GPL) are entitled to upgrade to the latest version of
Directory Opus version 5 at a reduced price. Please see
http://www.gpsoft.com.au for more information.

The release of Directory Opus 4 under the GPL in NO WAY affects
the existing commercial status of Directory Opus 5.

*/

#include "dopus.h"

struct recurse {
    struct recurse *last;
    char *dir,*dest;
    int data;
    APTR data2;
    APTR data3;
    BPTR lock;
    struct FileInfoBlock *info;
};

struct recurse *current_recurse;

recursedir(fdir,fdest,dowhat,fdata)
char *fdir,*fdest;
int dowhat,fdata;
{
    BPTR mylock;
    struct FileInfoBlock __aligned myfinfo;
    struct FileInfoBlock __aligned enfinfo;
    char *name,*dir,*dest,*dname,*ddir,*adir,*adest,*ndir,*ndest;
    int suc,cont,ret,a,err,w1=1-data_active_window,adata,depth,b,rtry,data,*pstuff,blocks;
    struct recpath *crec=NULL,*trec;
    struct RecursiveDirectory
        *cur_recurse,*addparent_recurse,*new_rec,*pos_rec,*cur_parent,
        *cur_lastparent=NULL;
    APTR data2=NULL,adata2=NULL,data3=NULL,adata3=NULL;
    struct DOpusRemember *recurserem=NULL;
    struct makedirlist *first_makedir=NULL;

    if (dowhat&R_STARDIR) {
        rec_firstpath=NULL;
        rec_pathkey=NULL;
    }

    if (dowhat&R_GETNAMES) {
        first_recurse=NULL;
        recurse_dir_key=NULL;
        cur_recurse=NULL;
        addparent_recurse=NULL;
    }

    data=fdata;

    current_recurse=NULL; ret=depth=0; recurse_max_depth=0;
    dos_global_bytecount=0;
    dos_global_copiedbytes=0;
    dos_global_deletedbytes=0;
    dos_global_blocksneeded=0;

    if (!(mylock=Lock(fdir,ACCESS_READ))) {
        doerror(IoErr());
        return(-1);
    }
    Examine(mylock,&myfinfo);

    if (!(name=LAllocRemember(&recurserem,2560,MEMF_CLEAR))) {
        doerror(IoErr());
        ret=-1;
        goto goaway;
    }
    dir=name+512; dest=name+1024; dname=name+1536; ddir=name+2048;
    if (fdir) strcpy(dir,fdir);
    if (fdest) strcpy(dest,fdest);

    if (dowhat&R_COPY) {
        strcpy(ddir,dest);
        if (!(a=copymakedir(&recurserem,&first_makedir,dest,&myfinfo)) || a==-1) {
            UnLock(mylock);
            if (a==0) ret=-3;
            else ret=-10;
            goto goaway;
        }
    }
    cont=ExNext(mylock,&myfinfo);

    FOREVER {
        if (status_haveaborted) {
            myabort();
            ret=-10;
            break;
        }
        if (!cont) {
            if (current_recurse) {
                if (mylock) UnLock(mylock);
                strcpy(dname,dir);
                mylock=current_recurse->lock;
                CopyMem((char *)current_recurse->info,(char *)&myfinfo,sizeof(struct FileInfoBlock));
                strcpy(dir,current_recurse->dir);
                strcpy(dest,current_recurse->dest);
                data=current_recurse->data;
                data2=current_recurse->data2;
                data3=current_recurse->data3;
                current_recurse=current_recurse->last;

                strcpy(name,dir);
                TackOn(name,myfinfo.fib_FileName,512);

                if (dowhat&R_GETNAMES) {
                    cur_recurse=(struct RecursiveDirectory *)data2;
                    cur_lastparent=(struct RecursiveDirectory *)data3;
                    addparent_recurse=NULL;
                }

                if (dowhat&R_COPY) {
                    strcpy(ddir,dest);
                    if (config->copyflags&COPY_DATE) {
                        TackOn(ddir,myfinfo.fib_FileName,512);
                        setdate(ddir,&myfinfo.fib_Date);
                        strcpy(ddir,dest);
                    }
                }

                a=0;
                if (dowhat&R_COMMENT) {
                    FOREVER {
                        if (!(SetComment(name,dest))) {
                            err=IoErr();
                            doerror(err);
                            a=checkerror(globstring[STR_COMMENTING],myfinfo.fib_FileName,err);
                            if (a==1) continue;
                        }
                        break;
                    }
                    if (a==3) break;
                }

                if (dowhat&R_PROTECT) {
                    pstuff=(int *)data;
                    b=getnewprot(myfinfo.fib_Protection,pstuff[0],pstuff[1]);
                    FOREVER {
                        if (!(SetProtection(name,b))) {
                            err=IoErr();
                            doerror(err);
                            a=checkerror(globstring[STR_PROTECTING],myfinfo.fib_FileName,err);
                            if (a==1) continue;
                        }
                        break;
                    }
                    if (a==3) break;
                }

                if (dowhat&R_DATESTAMP) {
                    FOREVER {
                        if ((err=setdate(name,(struct DateStamp *)data))!=1) {
                            doerror(err);
                            a=checkerror(globstring[STR_DATESTAMPING],myfinfo.fib_FileName,err);
                            if (a==1) continue;
                        }
                        break;
                    }
                    if (a==3) break;
                }

                cont=ExNext(mylock,&myfinfo);

                if (dowhat&R_DELETE && depth>0) {
                    a=strlen(dname);
                    if (a>0 && dname[a-1]=='/') dname[a-1]=0;
                    if ((a=delfile(dname,BaseName(dname),globstring[STR_DELETING],
                        glob_unprotect_all,1))==-1) {
                        myabort();
                        ret=-10;
                        break;
                    }
                    if (a==2) glob_unprotect_all=1;
                }
                --depth;
                continue;
            }
            else break;
        }
        CopyMem((char *)&myfinfo,(char *)&enfinfo,sizeof(struct FileInfoBlock));

        strcpy(name,dir);
        TackOn(name,enfinfo.fib_FileName,512);

        if (enfinfo.fib_DirEntryType>0) {
            ++dos_global_blocksneeded;
            if (enfinfo.fib_DirEntryType!=4) {
                adir=NULL;
                dofilename(name);
                if (dowhat&R_GETNAMES) {
                    if (new_rec=LAllocRemember(&recurse_dir_key,sizeof(struct RecursiveDirectory),MEMF_CLEAR)) {
                        strcpy(new_rec->name,enfinfo.fib_FileName);
                        CopyMem((char *)&enfinfo.fib_Date,(char *)&new_rec->date,sizeof(struct DateStamp));
                        if (addparent_recurse) {
                            addparent_recurse->child=new_rec;
                            cur_lastparent=addparent_recurse;
                            cur_recurse=new_rec;
                        }
                        else if (!first_recurse) {
                            first_recurse=new_rec;
                            cur_recurse=new_rec;
                        }
                        else if (cur_recurse) {
                            if (LStrCmpI(new_rec->name,cur_recurse->name)<0) {
                                if (first_recurse==cur_recurse) first_recurse=new_rec;
                                if (cur_lastparent && cur_lastparent->child==cur_recurse)
                                    cur_lastparent->child=new_rec;
                                new_rec->next=cur_recurse;
                                cur_recurse=new_rec;
                            }
                            else {
                                pos_rec=cur_recurse;
                                FOREVER {
                                    if (!pos_rec->next ||
                                        (LStrCmpI(new_rec->name,pos_rec->next->name)<0)) {
                                        new_rec->next=pos_rec->next;
                                        pos_rec->next=new_rec;
                                        break;
                                    }
                                    pos_rec=pos_rec->next;
                                }
                            }
                        }
                        else cur_recurse=new_rec;
                        cur_parent=new_rec;
                    }
                    adir=dir; adest=dest; ndir=name; ndest=dest;
                    adata2=(APTR)cur_recurse;
                    adata3=(APTR)cur_lastparent;
                    addparent_recurse=cur_parent;
                }
                strcpy(dname,dest);
                if (dowhat&R_COPY) {

                    dotaskmsg(hotkeymsg_port,PROGRESS_UPDATE,-2,0,enfinfo.fib_FileName,1);

                    TackOn(dname,enfinfo.fib_FileName,512);
                    adir=dir; adest=dest; adata=data; ndir=name; ndest=dname;
                    strcpy(ddir,dname);
                    if ((a=copymakedir(&recurserem,&first_makedir,ddir,&enfinfo))==-1) {
                        ret=-10;
                        break;
                    }
                    else if (a==0) adir=NULL;
                }
                if (dowhat&R_DELETE) {
                    rtry=1;
delloop:
                    if (!DeleteFile(name)) {
                        if (config->deleteflags&8 && rtry==1 && IoErr()==222) {
                            rtry=0;
                            SetProtection(name,0);
                            goto delloop;
                        }
                        adir=dir; adest=dest; adata=data; ndir=name; ndest=dname;
                    }
                    else {
                        if (config->dynamicflags&1) seename(data_active_window);
                        adir=NULL;
                    }
                }
                if (dowhat&R_HUNT || dowhat&R_SEARCH || dowhat&R_COMMENT ||
                    dowhat&R_PROTECT || dowhat&R_DATESTAMP || dowhat&R_GETBYTES ||
                    dowhat&R_STARDIR) {
                    adir=dir; adest=dest; adata=data; ndir=name; ndest=dest;
                    adata2=data2; adata3=data3;
                }
                if (adir) {
                    if (!(addrecurse(&recurserem,adir,adest,adata,adata2,adata3,mylock,&enfinfo))) {
                        cont=0;
                        continue;
                    }
                    strcpy(dir,ndir);
                    strcpy(dest,ndest);
                    if (!(mylock=Lock(dir,ACCESS_READ))) {
                        cont=0;
                        continue;
                    }
                    Examine(mylock,&myfinfo);
                    cont=ExNext(mylock,&myfinfo);
                    ++depth;
                    if (depth>recurse_max_depth) recurse_max_depth=depth;
                    continue;
                }
            }
        }
        cont=ExNext(mylock,&myfinfo);

        if (enfinfo.fib_DirEntryType<0) {
            a=0;
            dos_global_bytecount+=enfinfo.fib_Size;
            if (dowhat&R_GETBYTES && data) {
                blocks=(enfinfo.fib_Size+(data-1))/data;
                dos_global_blocksneeded+=blocks+(blocks/72)+1;
            }

            if (dowhat&R_GETNAMES) goto skipgetnam;
//            dofilename(name);
            if (!(dowhat & (R_GETBYTES | R_HUNT))) dofilename(name);
            if (dowhat&R_STARDIR) {
                if ((trec=LAllocRemember(&rec_pathkey,sizeof(struct recpath),MEMF_CLEAR)) &&
                    (trec->path=LAllocRemember(&rec_pathkey,(strlen(name)+1)-data,MEMF_CLEAR))) {
                    trec->next=NULL;
                    strcpy(trec->path,&name[data]);
                    if (crec) crec->next=trec;
                    crec=trec;
                    if (!rec_firstpath) rec_firstpath=trec;
                }
            }
            if (!str_filter_parsed[0] ||
                LMatchPatternI(str_filter_parsed,enfinfo.fib_FileName)) {
                if (dowhat&R_COPY) {
                    strcpy(dname,ddir);
                    TackOn(dname,enfinfo.fib_FileName,512);

                    dotaskmsg(hotkeymsg_port,PROGRESS_UPDATE,-2,0,enfinfo.fib_FileName,1);

                    a=0;
                    FOREVER {
                        if (!(a=copyfile(name,dname,&err,-1,NULL,0))) {
                            doerror(err);
                            a=checkerror(globstring[STR_COPYING],enfinfo.fib_FileName,err);
                            if (a==1) continue;
                            if (a!=3) seename(data_active_window);
                        }
                        else if (a==-1) {
                            myabort();
                            a=3;
                            break;
                        }
                        else {
                            if (dowhat==R_COPY) {
                                if (config->copyflags&COPY_ARC && !(enfinfo.fib_Protection&FIBF_ARCHIVE))
                                    SetProtection(name,enfinfo.fib_Protection|FIBF_ARCHIVE);
                            }
                            dos_global_copiedbytes+=enfinfo.fib_Size;
                        }
                        if (config->dynamicflags&1) seename(data_active_window);
                        break;
                    }
                    if (a==3) {
                        ret=-10;
                        break;
                    }
                    if (config->dynamicflags&1) {
                        seename(data_active_window); seename(w1);
                    }
                }
                if (dowhat&R_DELETE) {
                    if ((a=delfile(name,enfinfo.fib_FileName,globstring[STR_DELETING],
                        glob_unprotect_all,1))==-1) {
                        myabort();
                        ret=-10;
                        break;
                    }
                    if (a==2) glob_unprotect_all=1;
                    if (config->dynamicflags&1) seename(data_active_window);
                    dos_global_deletedbytes+=enfinfo.fib_Size;
                }
                if (dowhat&R_COMMENT) {
                    FOREVER {
                        if (!(SetComment(name,dest))) {
                            err=IoErr();
                            doerror(err);
                            a=checkerror(globstring[STR_COMMENTING],enfinfo.fib_FileName,err);
                            if (a==1) continue;
                        }
                        break;
                    }
                    if (a==3) {
                        ret=-10;
                        break;
                    }
                }
                if (dowhat&R_PROTECT) {
                    pstuff=(int *)data;
                    b=getnewprot(enfinfo.fib_Protection,pstuff[0],pstuff[1]);
                    FOREVER {
                        if (!(SetProtection(name,b))) {
                            err=IoErr();
                            doerror(err);
                            a=checkerror(globstring[STR_PROTECTING],enfinfo.fib_FileName,err);
                            if (a==1) continue;
                        }
                        break;
                    }
                    if (a==3) {
                        ret=-10;
                        break;
                    }
                }
                if (dowhat&R_DATESTAMP) {
                    FOREVER {
                        if ((err=setdate(name,(struct DateStamp *)data))!=1) {
                            err=IoErr();
                            doerror(err);
                            a=checkerror(globstring[STR_DATESTAMPING],enfinfo.fib_FileName,err);
                            if (a==1) continue;
                        }
                        break;
                    }
                    if (a==3) {
                        ret=-10;
                        break;
                    }
                }
                if (dowhat&R_HUNT) {
                    suc=huntfile(enfinfo.fib_FileName,name,&a);
                    ret+=a;
                    if (suc) {
                        if (suc==-1) {
                            myabort();
                            ret=-10;
                        }
                        else ret=suc;
                        break;
                    }
                }
                if (dowhat&R_SEARCH) {
                    suc=filesearch(name,&a,0);
                    ret+=a;
                    busy();
                    if (suc==2) {
                        if (!simplerequest(globstring[STR_CONTINUE_WITH_SEARCH],
                            globstring[STR_CONTINUE],str_cancelstring,NULL)) {
                            okay();
                            ret=-2;
                            break;
                        }
                    }
skipgetnam:
                    if (suc==-1) {
                        myabort();
                        ret=-10;
                        break;
                    }
                }
            }
        }
    }
    if (mylock) UnLock(mylock);
    while (current_recurse) {
        UnLock(current_recurse->lock);
        current_recurse=current_recurse->last;
    }
    if (first_makedir &&
        dowhat==R_COPY &&
        str_filter_parsed[0]) {

        struct makedirlist *last;

        last=first_makedir;
        while (last->next) last=last->next;

        while (last) {
            DeleteFile(last->path);
            last=last->last;
        }
    }
goaway:
    if (recurserem) LFreeRemember(&recurserem);
    return(ret);
}

addrecurse(key,dir,dest,data,data2,data3,lock,info)
struct DOpusRemember **key;
char *dir,*dest;
int data;
APTR data2,data3;
BPTR lock;
struct FileInfoBlock *info;
{
    struct recurse *rec;

    if (!(rec=LAllocRemember(key,sizeof(struct recurse),MEMF_CLEAR)))
        return(0);
    if (current_recurse) rec->last=current_recurse;
    else rec->last=NULL;
    if (!(rec->dir=LAllocRemember(key,strlen(dir)+1,MEMF_CLEAR)) ||
        !(rec->dest=LAllocRemember(key,strlen(dest)+1,MEMF_CLEAR)))
        return(0);
    strcpy(rec->dir,dir); strcpy(rec->dest,dest);
    rec->data=data;
    rec->data2=data2;
    rec->data3=data3;
    rec->lock=lock;
    if (!(rec->info=LAllocRemember(key,sizeof(struct FileInfoBlock),0)))
        return(0);
    CopyMem((char *)info,(char *)rec->info,sizeof(struct FileInfoBlock));
    current_recurse=rec;
    return(1);
}

copymakedir(key,first,dirname,finfo)
struct DOpusRemember **key;
struct makedirlist **first;
char *dirname;
struct FileInfoBlock *finfo;
{
    int exist,a,err;
    BPTR mylock;

    exist=CheckExist(dirname,NULL);
    if (exist<=0) {
loop:
        if (exist<0 || !(mylock=CreateDir(dirname))) {
            if (exist<0) err=203;
            else err=IoErr();
            doerror(err);
            a=checkerror(globstring[STR_CREATING],finfo->fib_FileName,err);
            if (a==1) goto loop;
            if (a==2) return(0);
            return(-1);
        }
        if (mylock) {
            struct makedirlist *list,*pos;

            UnLock(mylock);

            if (config->copyflags&COPY_DATE) setdate(dirname,&finfo->fib_Date);
            if (config->copyflags&COPY_PROT) SetProtection(dirname,finfo->fib_Protection);
            if (config->copyflags&COPY_NOTE) SetComment(dirname,finfo->fib_Comment);

            if ((list=LAllocRemember(key,sizeof(struct makedirlist),MEMF_CLEAR)) &&
                (list->path=LAllocRemember(key,strlen(dirname)+1,0))) {
                strcpy(list->path,dirname);
                if (!(pos=*first)) *first=list;
                else {
                    while (pos->next) pos=pos->next;
                    pos->next=list;
                    list->last=pos;
                }
            }
        }
    }
    return(1);
}