/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include <fcntl.h>

#include <stdio.h>

#include <sys/stat.h>

#include <string.h>

#include <unistd.h>

#include <string>

#include <sstream>

#include "cpixfstools.h"

#include "cpixstrtools.h"

namespace

{

    const char DIR_SEPARATOR = '\\';

}

namespace Cpt

{

    int getparent(char       * parent, 

                  size_t       bufSize,

                  const char * child)

    {

        size_t

            len = strlen(child);

	if (child[len-1] == '\\' ||

            child[len-1] == '/') {

            len--;

	}

	size_t

            i = len-1;

            char c = child[i];

            if (c == '\\' ||

                c == '/') {

                // found parent path 

                break;

            }

            i--;

	}

	if (i+1 >= FILENAME_MAX 

            return -1;

	}

        memcpy(parent, child, i);

        parent[i] = 0;

        return 0;

    }

    bool directoryexists(const char * path)

    {

        bool

            rv = false;

	DIR

            * d = NULL;

        Cpt_EINTR_RETRY_PTR(d, opendir(path));

	if (d) {

            rv = true;

	} 

        return rv;

    }

    /**

     * This class can be used in two distinct modes:

     *

     *  (a) removes everything, including the directory where

     *      the traversal was started (default constructor)

     *

     *  (b) removes only stuff under the start directory (constructor

     *      with path argument to start directory).

     */

    class Remover : public IFileVisitor

    {

        int              success_;

        std::string      start_;

    public:

        Remover()

            : success_(0)

        {

            ;

        }

        Remover(const char * start)

            : success_(0),

              start_(start)

        {

            ;

        }

        int success() const

        {

            return success_;

        }

        virtual bool visitFile(const char * path)

        {

            // 'remove' works for files and directories

            Cpt_EINTR_RETRY(success_,remove(path));

            return success_ == 0;

        }

        virtual DirVisitResult visitDirPre(const char * /*path*/)

        {

            return IFV_CONTINUE;

        }

        virtual bool visitDirPost(const char * path)

        {

            bool

                rv = true;

            if (start_.length() == 0

                || start_ != path)

                {

                    rv = visitFile(path);

                }

            return rv;

        }

    };

    int removeall(const char * path)

    {

        // this instance will remove anything

        Remover

            remover;

        traverse(path,

                 &remover);

        return remover.success();

    }

    int removeunder(const char * path)

    {

        // this instance will remove everything except the thing with

        // path 'path', which happens to be the directory where the

        // traversal starts

        Remover

            remover(path);

        traverse(path,

                 &remover);

        return remover.success();

    }

    int mkdirs(const char* path, int mod)

    {

        if (directoryexists(path))

            {

                return 0;

            }

        char 

            parent[FILENAME_MAX];

        if (getparent(parent, sizeof(parent), path) >= 0) {

            // make the parent

        } 

        return mkdir(path, mod);

    }

    int touch(const char * path,

              int          mod)

    {

        int

            fd;

        Cpt_EINTR_RETRY(fd,

                        open(path,

                             O_WRONLY | O_CREAT | O_TRUNC,

                             mod));

        if (fd != -1)

            {

            }

        return fd == -1 ? -1 : 0;

    }

    bool isreadable(const char * path)

    {

        int

            fd;

        Cpt_EINTR_RETRY(fd,

                        open(path,

                             O_RDONLY));

        bool

            rv = (fd != -1);

        if (rv)

            {

            }

        return rv;

    }

    bool isfile(const char * path)

    {

        bool

            rv = false;

        struct stat 

            buf;

        int

            res = lstat(path,

                        &buf);

        if (res == 0)

            {

                rv = static_cast<bool>(S_ISREG(buf.st_mode));

            }

        return rv;

    }

    off_t filesize(const char * path)

    {

        off_t

            rv = 0;

        int

            res;

        struct stat

            buf;

        res = stat(path,

                   &buf);

        if (res == 0)

            {

                rv = buf.st_size;

            }

        return rv;

    }

    off_t filesize(int fileDesc)

    {

        off_t

            rv = 0;

        int

            res;

        struct stat buf;

        res = fstat(fileDesc,

                    &buf);

        if (res == 0)

            {

                rv = buf.st_size;

            }

        return rv;

    }

    time_t filemodified(const char * path)

    {

        time_t

            rv = 0;

        int

            res;

        struct stat buf;

        res = stat(path,

                   &buf);

        if (res == 0)

            {

                rv = buf.st_mtime;

            }

        return rv;

    }

    bool fgetline(FILE* file, std::string& line)

   	{

		std::ostringstream buf; 

    	while (!feof(file))

    	{

    		int c = fgetc(file);

    		if (c == EOF || c == '\n') {

				break;

    		}

    		buf<<(char)c; 

    	}

    	line = buf.str(); 

		return !feof(file);

   	}

    int copyFile(const char * dstPath,

                 const char * srcPath)

    {

        int

            rv = CPT_CPF_OK;

        ssize_t

            res;

        int

            dstFD;

        Cpt_EINTR_RETRY(dstFD,open(dstPath,

                                   O_WRONLY | O_TRUNC | O_CREAT,

                                   0666));

        if (dstFD == -1)

            {

                rv = CPT_CPF_DST_OPEN_ERROR;

                return rv;

            }

        int

            srcFD;

        Cpt_EINTR_RETRY(srcFD,open(srcPath,

                                   O_RDONLY));

        if (srcFD == -1)

            {

                Cpt_EINTR_RETRY(res,close(dstFD));

                rv = CPT_CPF_SRC_OPEN_ERROR;

                return rv;

            }

        char

            buffer[256];

        ssize_t

            readC = 0;

        while (true)

            {

                Cpt_EINTR_RETRY(readC,read(srcFD, 

                                           buffer, 

                                           sizeof(buffer)

                                           /sizeof(char)));

                if (readC == -1)

                    {

                        rv = CPT_CPF_SRC_READ_ERROR;

                        break;

                    }

                else if (readC == 0)

                    {

                        // end of file

                        break;

                    }

                else

                    {

                        ssize_t

                            writtenC = 0;

                        while (writtenC < readC)

                            {

                                Cpt_EINTR_RETRY(res,write(dstFD,

                                                          buffer + writtenC,

                                                          readC - writtenC));

                                if (res == -1)

                                    {

                                        rv = CPT_CPF_DST_WRITE_ERROR;

                                        break;

                                    }

                                else

                                    {

                                        writtenC += res;

                                    }

                            }

                    }

            }

        Cpt_EINTR_RETRY(res,close(srcFD));

        Cpt_EINTR_RETRY(res,close(dstFD));

        return rv;

    }

    /**

     * A file visitor that can copy files and directories.

     */

    class Copier : public IFileVisitor

    {

        int          result_;

        bool         inclusive_;

        std::string  srcBasePath_;

        std::string  dstBasePath_;

    public:

        Copier(const char * dstPath,

               const char * srcPath,

               bool         inclusive)

            : result_(CPT_CP_INVALID_ARG_ERROR),