#include <list>
#include <vector>
#include "GRIB_Functions.h"

namespace Weather
{
    template <class T>
    class DeleteList : public std::list<T *>
    {
    public:

        ~DeleteList()
        {
            std::list<T *>::iterator ptrEnd = end();
            for (std::list<T *>::iterator ptrStart = begin();
                 ptrStart != ptrEnd;
                 ptrStart++)
            {
                delete (*ptrStart);
            }
        }
    };

    typedef TREE::Wrap<float, float, 2> GribTree;
    typedef DeleteList<struct Product>  ProductList;
    typedef DeleteList<struct Group>    GroupList;
    typedef DeleteList<class Host>      HostList;

    enum Error
    {
        SUCCESS                   = 0,
        DESCRIPTION_TOO_LARGE     = 1,
        COULD_NOT_CONNECT_TO_HOST = 2,
        COULD_NOT_SEND_REQUEST    = 3,
        COULD_NOT_READ_REPLY      = 4,
    };

    struct Product
    {
        enum Status
        {
            STATUS_UNKNOWN,
            STATUS_DOWNLOADING,
            STATUS_DOWNLOADED,
            STATUS_STOPPED,
        };

        enum LockResult
        {
            LOCK_SUCCESS      = 0,
            LOCK_ERROR        = 1,
            LOCK_TIME_EXPIRED = 2,
            LOCK_FILE_MISSING = 3,
        };

        Status              m_enmStatus;
        UTIL::File          m_clsLockFile;
        UTIL::Time          m_stuTime;
        std::vector<char *> m_clsRemoteFiles;
        class Host *        m_ptrHost;
        unsigned char *     m_ptrTypes;
        char *              m_ptrDescription;
        char *              m_ptrCategory;
        char *              m_ptrFileLock;
        char *              m_ptrFileProxy;
        char *              m_ptrFileLocal;
        char *              m_ptrHostFile;
        char *              m_ptrFileDownloaded;
        UTIL::D2::Box       m_stuCorners;
        int                 m_intIntervals[3];
        bool                m_blnShouldBeDownloading;

        Product();
        ~Product();

        bool       Clean(const char * Directory, UTIL::Log & LogErr);
        bool       Init(const char * Directory, const bool CheckProductTime, ProductList & List, UTIL::Log & LogErr);
        LockResult Lock(const time_t SecondsToWait, UTIL::Time * TimeRef, UTIL::Log & Log);
        bool       Read(UTIL::Parser & Data);
        bool       ReadText(UTIL::Parser & Data);
        bool       Unlock(UTIL::Time * TimeRef = NULL, const bool DeleteProxy = false);
    };

    //struct ProductSimple
    //{
    //    char * m_ptrCategory;
    //    char * m_ptrDescription;
    //};

    struct Group
    {
        ProductList m_clsProducts;
        char *      m_ptrName;
        char *      m_ptrDirectory;

        Group();
        ~Group();

        bool        Init(const char * Directory, const bool CheckProductTime, UTIL::Log & Log);
        static bool Read(UTIL::Parser & Data, GroupList & List);
        static bool Read(const char * FileName, GroupList & List);
        void        Split(UTIL::Log & LogStd, UTIL::Log & LogErr);
    };

    class Access
    {
    public:

        typedef DeleteList<GRIB::Message> List;

        struct File
        {
            unsigned int m_uintInterval;
            unsigned int m_uintUsers;
            Access::List m_clsMessages;
            time_t       m_intTimeUnlock;

            File(unsigned int p_uintInterval);
        };

        struct Product
        {
            UTIL::Time               m_stuTime;
            char *                   m_ptrDirectory;
            Weather::Product *       m_ptrProduct;
            DeleteList<Access::File> m_clsFiles;
            unsigned int             m_uintUsers;
            time_t                   m_intTimeUnlock;

            Product();
            ~Product();
        };

    private:

        DeleteList<Access::Product> m_clsProducts;
        UTIL::Mutex                 m_clsMutex;

    public:

        Access();

        void              Clean(const time_t TimeToLive);
        Access::Product * Lock(const char * Directory, Weather::Product & Product, UTIL::Log & Log);
        Access::List *    Load(const unsigned int Interval, Access::Product & Product);
        bool              Unlock(Access::Product & Product, Access::List * ListRef = NULL);
    };

    class File
    {
    private:

        struct Part
        {
            GribTree **    ptrTrees;
            unsigned int * ptrTimes;
            unsigned int   uintType;
            unsigned int   uintAmount;
            float          fltDistance;

            Part() : ptrTrees(NULL), ptrTimes(NULL), uintType(0), uintAmount(0), fltDistance(0.0f) {}
        };

        bool              m_blnRequestSent;
        UTIL::D2::Box     m_stuCorners;
        UTIL::Time        m_clsTime;
        UTIL::Socket      m_clsSocket;
        std::vector<Part> m_clsParts;
        //UTIL::Array<Part> m_clsParts;

    public:

        File() {m_clsSocket.WaitTimeSet(300, 0);}
        File(const UTIL::Time BaseTime, UTIL::D2::Box Corners);
        ~File();

        bool  Add(const unsigned int Type, const float Distance, const unsigned int Amount, const unsigned int * Times);
        Error Create(const char * Server, const unsigned short Port, UTIL::Output * Out);
        Error Create(GroupList & Groups, Access & Access, UTIL::Output & Out, UTIL::Log & StdLog, UTIL::Log & ErrLog);
        bool  Parse(UTIL::Parser * Data);
    };

    class Host
    {
    private:

        struct ProductRef
        {
            Weather::Product & m_clsProduct;
            const char *       m_ptrRemoteName;

            ProductRef(Weather::Product & Product,
                       char * p_ptrRemoteName)
                : m_clsProduct(Product),
                  m_ptrRemoteName(p_ptrRemoteName) {}
        };

    public:

        enum Type
        {
            TYPE_UNKNOWN,
            TYPE_HTTP,
            TYPE_FTP,
        };

        enum Status
        {
            STATUS_UNKNOWN,
            STATUS_ERROR,
            STATUS_STARTING,
            STATUS_RUNNING,
            STATUS_COMPLETED_THREAD,
            STATUS_FINISHED,
            STATUS_EMPTY,
        };

        enum Error
        {
            ERROR_NONE,
            ERROR_UNKNOWN,
            ERROR_HOST_TIMEOUT,
            ERROR_NO_FILE_FOUND,
            ERROR_LOCAL_FILE,
            ERROR_COULD_NOT_CONNECT,
            ERROR_FAILED_NETWORK,
        };

        struct ThreadObjects
        {
            Host &       m_clsHost;
            const char * m_ptrTempPath;
            UTIL::Log &  m_clsLogStd;
            UTIL::Log &  m_clsLogErr;

            ThreadObjects(Host & Host,
                          const char * TempPath,
                          UTIL::Log & LogStd,
                          UTIL::Log & LogErr)
                : m_clsHost(Host),
                  m_ptrTempPath(TempPath),
                  m_clsLogStd(LogStd),
                  m_clsLogErr(LogErr) {}
        };

        Status                m_enmStatus;
        bool                  m_blnConnected;
        bool                  m_blnShouldBeRunning;
        char *                m_ptrName;
        char *                m_ptrAddress;
        char *                m_ptrUsername;
        char *                m_ptrPassword;
        char *                m_ptrCommonPath;
        int                   m_intAffinity;
        unsigned int          m_uintErrors;
        unsigned int          m_uintAllowableErrors;
        unsigned short        m_ushtPortLocal;
        unsigned short        m_ushtPortRemote;
        std::list<ProductRef> m_clsProducts;

        Host();
        virtual ~Host();

        unsigned int  Aggregate(const GroupList & Groups);
        void          CheckVersions(const GroupList & Groups, UTIL::Log & LogStd);
        virtual bool  Connect(void) = 0;
        virtual void  Disconnect(void) = 0;
        void          DownloadProducts(ProductList & List, const char * PathTemp, const char * PathFinal, UTIL::Log & LogStd, UTIL::Log & LogErr);
        int           DownloadProducts(const char * TempPath, UTIL::Log & LogStd, UTIL::Log & LogErr);
        static int    DownloadProductsThread(ThreadObjects * Objects);
        void          Finish(void);
        virtual Error GetFile(const char * p_ptrFileName, UTIL::Output & Out, UTIL::Log & LogStd, UTIL::Log & LogErr) = 0;
        Error         GetFile(const char * FileNameRemote, const char * FileNameLocal, UTIL::Log & LogStd, UTIL::Log & LogErr);
        virtual bool  GetFileTime(const char * p_ptrFileName) = 0;
        static bool   Read(UTIL::Parser & Data, HostList & Hosts);
        static bool   Read(const char * FileName, HostList & Hosts);
    };
}