#ifndef ADAPTIVEFIELD_H
#define ADAPTIVEFIELD_H

using namespace std;

class AdaptiveFieldCell;


class AdaptiveField
{
    friend class AdaptiveFieldCell;

public:
    AdaptiveField();
    virtual ~AdaptiveField();

    bool Generate(double radius, float resolution, bool generateGeometry);          // Create

    unsigned int GetMaxLod(){return m_MaxLOD;};
    double GetFieldSize(){return m_FieldSize;};

protected:
private:

    float m_FixedClamp;                             // fixed clamp - Perlin clamp level

    unsigned int m_MaxLOD;                          // Maximum LOD

    double m_FieldSize;                             // field size - can be number of polys (resolution)

    vector<AdaptiveFieldCell *> m_PatchRegion;    // Adaptive field;

    unsigned int m_Iteration;                      // Used this passed for interation

};

#endif // ADAPTIVEFIELD_H


// field  size is the physical size
// m_field size is the sizw



#include <memory>
#include <vector>
#include <cmath>

#include "../include/AdaptiveField.h"
#include "../include/AdaptiveFieldCell.h"

AdaptiveField::AdaptiveField()
{
 m_PatchRegion.resize(8);

}

AdaptiveField::~AdaptiveField()
{

}

// Generate each area field
bool AdaptiveField::Generate(double radius, float resolution, bool generateGeometry)
{
    // generate maxLOD;
    m_MaxLOD = (unsigned int)log2((float)(2.0f * 3.14 * radius) / 4/.0f);

    // override
    m_MaxLOD = 2;

    // radius is twice -- use for simplex
    m_FieldSize = radius*2;

    // default interation
    m_Iteration=1;

    // resize

    // Generate - translation would be x,y,z but flat
    for(unsigned int x=0; x<2; x++)
    {
        for(unsigned int y=0; y<2; y++)
        {
            for(unsigned int z=0; z<2; z++)
            {
                // Generate Cell
                AdaptiveFieldCell * newPatch = new AdaptiveFieldCell();

                newPatch->SetField(this);

                // Set locatoin
                newPatch->SetLocation(x,y,z);

                // add a new patch recursively till the final
                m_PatchRegion.push_back(newPatch);

                // Generate patch
                newPatch->Generate(m_Iteration+1);
            }
        }
    }

    return false;
}





#ifndef ADAPTIVEFIELDCELL_H
#define ADAPTIVEFIELDCELL_H

using namespace std;

class AdaptiveField;

struct bVector3
{
    bool x_;
    bool y_;
    bool z_;
};

struct uVector3
{
    unsigned int x;
    unsigned int y;
    unsigned int z;
};


// maybe can be similiar to terrainpatch
class AdaptiveFieldCell
{


public:
    AdaptiveFieldCell();
    virtual ~AdaptiveFieldCell();

    // Generate new cell
    virtual bool Generate(unsigned int interation);

    // Save root location
    void SetLocation(unsigned int x, unsigned int y, unsigned int z)
    {
        m_Location.x = x;
        m_Location.y = y;
        m_Location.z = z;
    };

    void SetField(AdaptiveField * passedField)
    {
        m_ParentField = passedField;
    };


protected:
private:
    vector <AdaptiveFieldCell *> m_PatchRegion;              // not set based on interation can be 8 or 1;

    bool m_IsLeaf;                                             // Final
    bool m_IsSolid;                                            // Solid

    AdaptiveField  * m_ParentField;                             // Parent Field;

    unsigned int m_Iteration;                                   // iteration

    uVector3 m_Location;                                        // Location

};

#endif // ADAPTIVEFIELDCELL_H



#include <memory>
#include <vector>
#include <iostream>

#include "../include/AdaptiveField.h"
#include "../include/AdaptiveFieldCell.h"

AdaptiveFieldCell::AdaptiveFieldCell()
{
    // Create region here
    // m_PatchRegion = new vector<AdaptiveFieldCell *>;

     m_PatchRegion.resize(8);

}

AdaptiveFieldCell::~AdaptiveFieldCell()
{

}


bool AdaptiveFieldCell::Generate(unsigned int interation=1)
{

    // if interaction
    if(interation>m_ParentField->GetMaxLod())
    {
        m_IsLeaf=true;

        m_Iteration = m_ParentField->GetMaxLod();
    }
    else
    {
        m_IsLeaf=false;

        m_Iteration = interation;
    }

    // if generate patch
    if(m_IsLeaf==false)
    {

        m_PatchRegion.resize(8);for(unsigned int x=0; x<2; x++)
        {
            for(unsigned int y=0; y<2; y++)
            {
                for(unsigned int z=0; z<2; z++)
                {
                    // Generate Cell
                    AdaptiveFieldCell * newPatch = (AdaptiveFieldCell *) new AdaptiveFieldCell;

                    // Set Location
                    newPatch->SetLocation(x,y,z);

                    // set field
                    newPatch->SetField(m_ParentField);

                    // add a new patch recursively till the final
                    m_PatchRegion.push_back(newPatch);


                    // Generate patch
                    newPatch->Generate(m_Iteration++);
                }
            }
        }
    }

    // if generate patch
    if(m_IsLeaf==true)
    {
        // Bit manipulation
        float sizecell=m_ParentField->GetFieldSize()/(1<<m_Iteration);

        cout << sizecell << endl;

    }

    return false;
}