#ifndef GLM_GRID_CELL_H_
#define GLM_GRID_CELL_H_

#include <ctime>
#include <iostream>
#include <string>

#include "config.h"


namespace glm {

   // Note: VRGN has to be first! SCND has to be second!
   enum lu_types { VRGN, SCND, URBN, CROP, PSTR, N_LU_TYPES };
   const char* getLandUseName(lu_types lu);
   std::string getFlowName(size_t source, size_t target);

   // Note:: PRIM types have to be first, SECD types have to be next!
   enum sub_lu_types { PRIMF, PRIMN, SECDF, SECDN, URBAN,
                       C3ANN, C4ANN, C3PER, C4PER, C3NFX,
                       PASTR, RANGE,
                       N_SUB_LU_TYPES };
   const char* getSubLandUseName(sub_lu_types lu);
   const char* getSubLandUseLongName(sub_lu_types lu);
   std::string getSubFlowName(size_t source, size_t target);

   class InputFiles;
   class Zone;
   class GridInfo;

   class GridCell {

      static double harvestProbability (double biomass, InputFiles& inputs);

   public:

      int zdis;
      int Ldis;

      struct State {

         double lu[N_LU_TYPES];
         double subLU[N_SUB_LU_TYPES];
         int priorWH;
	 double sc_c2s, sc_p2s, sc_v2c, sc_v2p, sc_s2c, sc_s2p, sc_c, sc_p, sc_v, sc_s;
	 double u_u2s, u_u2p, u_p2u, u_s2u, u_v2u;
         double scndMeanAge;
         double scndMeanBiomass;
         
         double RSForestLossRemaining;
         double landsat;

         double irrgData;
	 double riceData;
         double irrig[N_SUB_LU_TYPES];
         double fert[N_SUB_LU_TYPES];
         double cropBiofuels[N_SUB_LU_TYPES];
         double flooded;
         double shftCult;
         double iamFlood;
         double iamC4P;
         double iamC3P;
         double iamC3A;
         double iamC4A;
         double iamC3N;
         double iamFert[N_SUB_LU_TYPES];
         double iamIrrig[N_SUB_LU_TYPES];
         double iamCropBiofuel;
         double iamC3PBiofuel;
         double iamC4PBiofuel;

         double biomassHarvestFraction[N_SUB_LU_TYPES];
         double tillage;
         double fuelwoodFraction;
         double commercialBiofuelsFraction;
         double industrialRoundwoodFraction;
         double nonCropBiofuel;
         double totalCropBiofuel;
      };


      class Flows {

         double transitions[N_LU_TYPES][N_LU_TYPES];
         double subTransitions[N_SUB_LU_TYPES][N_SUB_LU_TYPES];

       public:

         inline double get(size_t from, size_t to) {
            return transitions[from][to];
         }

         inline void set(lu_types from, lu_types to, double flow) {
            transitions[from][to] = flow;
         }

         inline double getSub(size_t from, size_t to) {
            return subTransitions[from][to];
         }

         inline void setSub(sub_lu_types from, sub_lu_types to, double flow) {
            subTransitions[from][to] = flow;
         }

         inline double getFlowsAway(size_t from) {
            double away = 0.0;
            for (size_t to=VRGN+1; to<N_LU_TYPES; ++to) {
               away += get(from, to);
            }
            return away;
         }
         
         void resetNegatives(bool warn, const char* caller);
         void resetNegativeSubs(bool warn, const char* caller);

         double vrgnHarvArea1;
         double vrgnHarvArea2;
         double scndHarvArea1;
         double scndHarvArea2;
         double scndHarvArea3;

         double vrgnHarvBiomass1;
         double vrgnHarvBiomass2;
         double scndHarvBiomass1;
         double scndHarvBiomass2;
         double scndHarvBiomass3;


      };


      GridCell ();
      
      void init (size_t now, size_t y, size_t x, Zone* zone,
                 GridInfo& grid, InputFiles& stateInputs, Config& config);
      
      void loadInputs(size_t t, InputFiles& inputs, Config& config);
      void loadRestarts (size_t t, GridInfo& grid, Config& config); 
      void initNextStatesAndFlows (size_t next);
      void transitions (size_t now, size_t next, InputFiles& statesFiles,
                        Config& config, clock_t& sft, clock_t& asft, int year, GridInfo& grid);
      void harvest (size_t now, InputFiles& inputs, Config& config, int year);
      void cropRotations (size_t now, size_t next);
      void expandC4Perennials (size_t now, size_t next);
      void expandC3Perennials (size_t now, size_t next);
      void expandC4Annuals (size_t now, size_t next);
      void expandC3NFixing (size_t now, size_t next);
      void doSubTransitions (size_t now, size_t next, Config& config);
      void updateStates (size_t now, size_t next, Config& config);
      void updateCropTypesRatios (size_t now, Config& config);
      void updateForestLoss (size_t now, size_t next, int year);
      
      void disaggregateInitialLandUse(size_t now, GridInfo& grid, Config& config);
      void updateCropTypeTallies (size_t now);
      void updateFertTallies (size_t now);
      void updateIrrigTallies (size_t now, size_t next, Config& config);

      void updateSecondaryLands (size_t now, size_t next);
      void computeIrrigatedArea (size_t now);
      void computeIrrigatedAreaExtension (size_t now);
      void computeIrrigatedAreaFuture (size_t now, size_t next);
      void computeFertilizerAmount (size_t now);
      void computeFertilizerAmountExtension (size_t now);
      void computeFertilizerAmountFuture (size_t now, size_t next, Config& config);
      void computeTillageRate (size_t now);
      void computeFloodedFraction (size_t now);
      void computeFloodedFractionExtension (size_t now);
      void computeNationalFloodedFraction(size_t now, size_t next);
      void precomputeFutureFloodedFraction (size_t now, size_t next);
      void computeWHBiofuelFractions (size_t now);
      void computeCroplandBiofuelFractions (size_t now);
      void computeFutureCroplandBiofuelFractions (size_t now);
      void computeBiomassHarvestFraction (size_t now);

      float getStateForOutput (size_t now, sub_lu_types type) {
         return static_cast<float>(frac[now].subLU[type]);
      }
      float getFlowForOutput (sub_lu_types from, sub_lu_types to) {
         return static_cast<float>(flow.getSub(from, to));
      }
      float getIrrigForOutput (size_t now, sub_lu_types type) { 
         return static_cast<float>(frac[now].irrig[type]); 
      } 
      float getFertForOutput (size_t now, sub_lu_types type) {
         return static_cast<float>(frac[now].fert[type]); 
      }

     float getTotalCropBiofuel (size_t now) { return static_cast<float>(frac[now].totalCropBiofuel); }
     float getNonCropBiofuel (size_t now) { return static_cast<float>(frac[now].nonCropBiofuel); }

      float getFlooded (size_t now) { return static_cast<float>(frac[now].flooded); }
      float getTillage (size_t now) { return static_cast<float>(frac[now].tillage); }
      float getCroplandBiofuelsForOutput (size_t now, sub_lu_types type) { 
         return static_cast<float>(frac[now].cropBiofuels[type]); 
       } 
      float getBiomassHarvestForOutput (size_t now, sub_lu_types type) { 
         return static_cast<float>(frac[now].biomassHarvestFraction[type]); 
       } 

      float getFuelwoodFraction (size_t now) { return static_cast<float>(frac[now].fuelwoodFraction); }
      float getCommercialBiofuelFraction (size_t now) { return static_cast<float>(frac[now].commercialBiofuelsFraction); }
      float getRoundwoodFraction (size_t now) { return static_cast<float>(frac[now].industrialRoundwoodFraction); }

      float getVBH1 (size_t now) { return static_cast<float>(flow.vrgnHarvBiomass1); }
      float getVBH2 (size_t now) { return static_cast<float>(flow.vrgnHarvBiomass2); }
      float getSBH1 (size_t now) { return static_cast<float>(flow.scndHarvBiomass1); }
      float getSBH2 (size_t now) { return static_cast<float>(flow.scndHarvBiomass2); }
      float getSBH3 (size_t now) { return static_cast<float>(flow.scndHarvBiomass3); }

      float getVAH1 (size_t now) { return static_cast<float>(flow.vrgnHarvArea1); }
      float getVAH2 (size_t now) { return static_cast<float>(flow.vrgnHarvArea2); }
      float getSAH1 (size_t now) { return static_cast<float>(flow.scndHarvArea1); }
      float getSAH2 (size_t now) { return static_cast<float>(flow.scndHarvArea2); }
      float getSAH3 (size_t now) { return static_cast<float>(flow.scndHarvArea3); }

      float getSSMB (size_t now) { return static_cast<float>(frac[now].scndMeanBiomass);}
      float getSSMA (size_t now) { return static_cast<float>(frac[now].scndMeanAge); }

      float getZdis (size_t now) { return static_cast<float>(zdis); }
      float getLdis (size_t now) { return static_cast<float>(Ldis); }
      float getPotBio (size_t now) { return static_cast<float>(potentialBiomass); }

      float getRSLossRem (size_t now) { return static_cast<float>(frac[now].RSForestLossRemaining); }

      float getS2C_SC (size_t now) { return static_cast<float>(frac[now].sc_s2c); }
      float getV2C_SC (size_t now) { return static_cast<float>(frac[now].sc_v2c); }
      float getC2S_SC (size_t now) { return static_cast<float>(frac[now].sc_c2s); }

      inline
      bool hasLandUse (size_t now) {
         for (size_t lu=VRGN+1; lu<N_LU_TYPES; ++lu) {
                
            if (frac[now].lu[lu] > 0.0000001) {
             if (lu!=SCND) {
              if (lu==PSTR) {
                if (frac[now].subLU[PASTR] > 0.0000001) {
                  return true;
                }
              }
              
              else {
                return true;
              }
            }
            }
         }
     
         return false;
      }

      inline
      bool hasLandsat (size_t now) { 
        if (frac[now].landsat > 0.01*(1-ice-water)) {   
          return true;
        }
        return false;
      }

      inline
      void printState (size_t lu, size_t now, size_t next, const char* prefix=NULL) {
         if (prefix != NULL) {
            std::cout << prefix;
         }
         std::cout << getLandUseName((lu_types) lu) << "(t)=" << frac[now].lu[lu]
         << " " << getLandUseName((lu_types) lu) << "(t+1)=" << frac[next].lu[lu];
         for (size_t olu=VRGN; olu<N_LU_TYPES; ++olu) {
            if (lu != olu) {
               if (lu != VRGN) {
                  std::cout << getFlowName(olu, lu) << "=" << flow.get(olu, lu);
               }
               std::cout << getFlowName(lu, olu) << "=" << flow.get(lu, olu);
            }
         }
         std::cout << std::endl;
      }

      
      inline
      void printSubState (size_t lu, size_t now, size_t next, const char* prefix=NULL) {
         if (prefix != NULL) {
            std::cout << prefix;
         }
         std::cout << getSubLandUseName((sub_lu_types) lu) << "(t)=" << frac[now].subLU[lu]
                   << " " << getSubLandUseName((sub_lu_types) lu) << "(t+1)=" << frac[next].subLU[lu];
         for (size_t olu=PRIMF; olu<N_SUB_LU_TYPES; ++olu) {
            if (lu != olu) {
               if (lu != PRIMF && lu != PRIMN) {
                  std::cout << getSubFlowName(olu, lu) << "=" << flow.getSub(olu, lu);
               }
               std::cout << getSubFlowName(lu, olu) << "=" << flow.getSub(lu, olu);
            }
         }
         std::cout << std::endl;
      }

      inline
      void printAllStates (size_t now, size_t next, const char* prefix=NULL) {
         for (size_t lu=PRIMF; lu<N_SUB_LU_TYPES; ++lu) {
            printSubState (lu, now, next, prefix);
         }
      }

      Zone* zoneTotal;
      GridInfo* gridVals;

      // Coordinates on input grid
      size_t y;
      size_t x;
      double lat;
      double lon;

      bool   shiftingCultivation;
      double cellArea;
      double ice;
      double water;
      double shft;
      double flooded_ratio;
      double croptype_ratio[N_SUB_LU_TYPES];
      double croptype_ratio_total;
      
      State  frac[2];
      Flows  flow;

      double scndMatureForestBiomass;
      double scndYoungForestBiomass;
      double scndForestBiomass;
      double woodHarvestUnmet;
      double convertedForestLand;
      double convertedForestLandTotal;
      
      bool   potentialForest;
      double potentialBiomass; 
      double potentialNPP;
      double rsForestLoss;
      
      
   private:
      void urbanFlows (size_t now, size_t next);
      void alternativeSmartFlow (size_t now, size_t next, bool warn);
      void adjustSmartFlow (size_t now, int shft_cult, GridInfo& grid, Config& config);
      void updateBiomassTallies (size_t now, InputFiles& inputs, int year);
      

   };
   
}
#endif // GLM_GRID_CELL_H_