/**************************************************************************
* file:              dmpproject.cpp

* Author:            wanzhongping
* Date:              2021-07-07 16:46:54
* Email:             zhongpingw@chinadci.com
* copyright:         广州城市信息研究所有限公司
***************************************************************************/
#include <iostream>

#include <boost/algorithm/string/case_conv.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/typeof/typeof.hpp>
#include "dmpproject.h"
#include "dmptilelayer.h"
#include "dmpvectorlayer.h"
using namespace boost::property_tree;
DmpProject *DmpProject::project_ = nullptr;

DmpProject::DmpProject()
{
}

DmpProject *DmpProject::Instance()
{
  if (!project_)
  {
    project_ = new DmpProject;
  }
  return project_;
}

DmpProject::~DmpProject()
{
  if (this == project_)
  {
    project_ = nullptr;
  }

  std::map<std::string, DmpMapLayer *>::iterator iter = mapLayers_.begin();
  for (; iter != mapLayers_.end(); ++iter)
  {
    DmpMapLayer *mapLayer = iter->second;
    if (mapLayer)
    {
      delete mapLayer;
      mapLayer = nullptr;
    }
  }
  mapLayers_.clear();
}

bool DmpProject::Read(const std::string &data)
{
  try
  {
    std::istringstream stream(data);
    ptree pt;
    read_xml(stream, pt);
    projectName_ = pt.get<std::string>("dmap.<xmlattr>.projectname");
    version_ = pt.get<std::string>("dmap.<xmlattr>.version");

    //坐标系
    ptree pSpatialRef = pt.get_child("dmap.projectCrs.spatialrefsys");
    if (!crs_.readXml(pSpatialRef))
    {
      return false;
    }

    //图层
    ptree pLayers = pt.get_child("dmap.projectlayers");
    for (BOOST_AUTO(pos, pLayers.begin()); pos != pLayers.end(); ++pos)
    {
      DmpMapLayer *mapLayer = nullptr;
      ptree pLayer = pos->second;
      int layerType = pLayer.get<int>("<xmlattr>.type");
      if (layerType == 0)
      {
        //tile
        mapLayer = new DmpTileLayer();
        
      }
      else if (layerType == 1)
      {
        //vector
        mapLayer = new DmpVectorLayer();
      }
      else if (layerType == 2)
      {
        //image
      }
      else
      {
        return false;
      }
      if (mapLayer && mapLayer->readXml(pLayer))
      {
        std::string name = mapLayer->name();
        boost::to_upper(name);
        mapLayers_[name] = mapLayer;
      }
      else
      {
        return false;
      }
    }
  }
  catch (const std::exception &e)
  {
    std::cerr << e.what() << '\n';
    return false;
  }
  return true;
}

bool DmpProject::Write(const std::string &filename, const std::string &data)
{
  std::istringstream stream(data);
  boost::property_tree::ptree pt;
  boost::property_tree::read_xml(stream, pt);
  auto setting = boost::property_tree::xml_writer_make_settings<std::string>('\t', 1);
  boost::property_tree::write_xml(filename, pt, std::locale(), setting);
  return true;
}

bool DmpProject::WritePtree(boost::property_tree::ptree& ptDoc) 
{
  //目前还未完善 只支持 矢量图层
  boost::property_tree::ptree ptDmap;

  ptDmap.add("<xmlattr>.projectname",projectName_);
  ptDmap.add("<xmlattr>.version",version_);

  boost::property_tree::ptree ptProjectCrs;
  crs_.write(ptProjectCrs);
  ptDmap.add_child("projectCrs",ptProjectCrs);

  boost::property_tree::ptree ptProjectlayers;
  
  std::map<std::string, DmpMapLayer *>::iterator iter = mapLayers_.begin();
  for (; iter != mapLayers_.end(); ++iter)
  {
    DmpMapLayer *mapLayer = iter->second;
    if (mapLayer && mapLayer->type() == DmpMapLayerType::VectorLayer)
    {
      boost::property_tree::ptree ptlayer;
      ptlayer.add("<xmlattr>.type", "1");
      DmpVectorLayer *vectorMapLayer =(DmpVectorLayer *) mapLayer;
      vectorMapLayer->writeXml(ptlayer);
      ptProjectlayers.add_child("maplayer",ptlayer);
    }
  }

  ptDmap.add_child("projectlayers", ptProjectlayers);
  ptDoc.add_child("dmap",ptDmap);

  return true;
}

std::string  DmpProject::WriteJson()
{
  boost::property_tree::ptree ptDoc;
  WritePtree(ptDoc);
  std::stringstream stream; 
  write_json(stream, ptDoc);
  std::string data = stream.str();
  return data;
}

std::string DmpProject::WriteXml()
{
  boost::property_tree::ptree ptDoc;
  WritePtree(ptDoc);
  std::stringstream stream; 
  write_xml(stream, ptDoc);
  std::string data = stream.str();
  return data;
}

DmpCoordinateReferenceSystem DmpProject::crs() const
{
  return crs_;
}

std::map<std::string, DmpMapLayer*> DmpProject::mapLayers() const
{
  return mapLayers_;
}

DmpMapLayer *DmpProject::getLayer(const std::string &layerName) const
{
  if(layerName.empty()){
    return getLayer();
  }
  std::string name = boost::to_upper_copy(layerName); 
  std::map<std::string, DmpMapLayer*>::const_iterator iter = mapLayers_.find(name);
  if (iter != mapLayers_.end())
  {
    return iter->second;
  }
  else
  {
    return nullptr;
  }
}

DmpMapLayer *DmpProject::getLayer() const
{
  std::map<std::string, DmpMapLayer*>::const_iterator iter = mapLayers_.begin();
  if (iter != mapLayers_.end())
  {
    return iter->second;
  }
  else
  {
    return nullptr;
  }
}