//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : ToolData.cpp       Data : 04.06.15          Versione : 1.6f1
// Contenuto : Implementazione struttura dati utensile.
//
//
//
// Modifiche : 04.06.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "ToolData.h"
#include "/EgtDev/Include/EMkToolConst.h"
#include "/EgtDev/Include/EGkGeoConst.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDEv/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EGnEgtUUID.h"
#include <array>
#include <cassert>

using namespace std ;

//----------------------------------------------------------------------------
enum nToolKey {
   TK_ABSMAX = 0,
   TK_COOLANT,
   TK_COR,
   TK_CRAD,
   TK_D,
   TK_DRAW,
   TK_DT,
   TK_EXI,
   TK_F,
   TK_FE,
   TK_FM,
   TK_FS,
   TK_FT,
   TK_HEA,
   TK_L,
   TK_LT,
   TK_MM,
   TK_NAME,
   TK_NS,
   TK_NU,
   TK_OL,
   TK_OR,
   TK_S,
   TK_SANG,
   TK_SM,
   TK_SUP,
   TK_TH,
   TK_TYP,
   TK_UUID,
   TK_ZZZ} ;        // rappresenta il numero di elementi

static const array<string,TK_ZZZ> sToolKey = {
   "ABSMAX",
   "COOLANT",
   "COR",
   "CRAD",
   "D",
   "DRAW",
   "DT",
   "EXI",
   "F",
   "FE",
   "FM",
   "FS",
   "FT",
   "HEA",
   "L",
   "LT",
   "MM",
   "NAME",
   "NS",
   "NU",
   "OL",
   "OR",
   "S",
   "SANG",
   "SM",
   "SUP",
   "TH",
   "TYP",
   "UUID"} ;

//----------------------------------------------------------------------------
int
ToolData::GetSize( void)
{
  // in debug verifico validità ultimo campo
   assert( sToolKey[TK_UUID] == "UUID") ;
   return TK_ZZZ ;
}

//----------------------------------------------------------------------------
int
FindToolKey( const string& sKey)
{
   auto TheRange = equal_range( sToolKey.cbegin(), sToolKey.cend(), sKey) ;
   if ( TheRange.first == TheRange.second)
      return - 1 ;
   return int( TheRange.first - sToolKey.cbegin()) ;
}

//----------------------------------------------------------------------------
bool
ToolData::FromString( const string& sString, int& nKey)
{
  // separo chiave da valore
   string sKey, sVal ;
   SplitFirst( sString, "=", sKey, sVal) ;
  // riconosco la chiave
   nKey = FindToolKey( ToUpper( sKey)) ;
   bool bOk = ( nKey >= 0) ;
   switch ( nKey) {
   case TK_ABSMAX :
      bOk = ::FromString( sVal, m_dMaxAbsorption) ;
      break ;
   case TK_COOLANT :
      bOk = ::FromString( sVal, m_nCoolant) ;
      break ;
   case TK_COR :
      bOk = ::FromString( sVal, m_nCorr) ;
      break ;
   case TK_CRAD :
      bOk = ::FromString( sVal, m_dCornRad) ;
      break ;
   case TK_D :
      bOk = ::FromString( sVal, m_dDiam) ;
      break ;
   case TK_DRAW :
      m_sDraw = sVal ;
      break ;
   case TK_DT :
      bOk = ::FromString( sVal, m_dTDiam) ;
      break ;
   case TK_EXI :
      bOk = ::FromString( sVal, m_nExit) ;
      break ;
   case TK_F :
      bOk = ::FromString( sVal, m_dFeed) ;
      break ;
   case TK_FE :
      bOk = ::FromString( sVal, m_dEndFeed) ;
      break ;
   case TK_FM :
      bOk = ::FromString( sVal, m_dMinFeed) ;
      break ;
   case TK_FS :
      bOk = ::FromString( sVal, m_dStartFeed) ;
      break ;
   case TK_FT :
      bOk = ::FromString( sVal, m_dTipFeed) ;
      break ;
   case TK_HEA :
      m_sHead = sVal ;
      break ;
   case TK_L :
      bOk = ::FromString( sVal, m_dLen) ;
      break ;
   case TK_LT :
      bOk = ::FromString( sVal, m_dTLen) ;
      break ;
   case TK_MM :
      bOk = ::FromString( sVal, m_dMaxMat) ;
      break ;
   case TK_NAME :
      m_sName = sVal ;
      bOk = ! m_sName.empty() ;
      break ;
   case TK_NS :
      m_sSysNotes = sVal ;
      break ;
   case TK_NU :
      m_sUserNotes = sVal ;
      break ;
   case TK_OL :
      bOk = ::FromString( sVal, m_dOffsL) ;
      break ;
   case TK_OR :
      bOk = ::FromString( sVal, m_dOffsR) ;
      break ;
   case TK_S :
      bOk = ::FromString( sVal, m_dSpeed) ;
      break ;
   case TK_SANG :
      bOk = ::FromString( sVal, m_dSideAng) ;
      break ;
   case TK_SM :
      bOk = ::FromString( sVal, m_dMaxSpeed) ;
      break ;
   case TK_SUP :
      m_sTcPos = sVal ;
      break ;
   case TK_TH :
      bOk = ::FromString( sVal, m_dThick) ;
      break ;
   case TK_TYP :
      bOk = ::FromString( sVal, m_nType) ;
      break ;
   case TK_UUID :
      bOk = ::FromString( sVal, m_Uuid) ;
      break ;
   default :
      bOk = false ;
      break ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
string
ToolData::ToString( int nInd) const
{
   switch ( nInd) {
   case TK_ABSMAX : return ( sToolKey[TK_ABSMAX] + "=" + ::ToString( m_dMaxAbsorption)) ;
   case TK_COOLANT : return ( sToolKey[TK_COOLANT] + "=" + ::ToString( m_nCoolant)) ;
   case TK_COR : return ( sToolKey[TK_COR] + "=" + ::ToString( m_nCorr)) ;
   case TK_CRAD : return ( sToolKey[TK_CRAD] + "=" + ::ToString( m_dCornRad)) ;
   case TK_D : return ( sToolKey[TK_D] + "=" + ::ToString( m_dDiam)) ;
   case TK_DRAW : return ( sToolKey[TK_DRAW] + "=" + m_sDraw) ;
   case TK_DT : return ( sToolKey[TK_DT] + "=" + ::ToString( m_dTDiam)) ;
   case TK_EXI : return ( sToolKey[TK_EXI] + "=" + ::ToString( m_nExit)) ;
   case TK_F : return ( sToolKey[TK_F] + "=" + ::ToString( m_dFeed)) ;
   case TK_FE : return ( sToolKey[TK_FE] + "=" + ::ToString( m_dEndFeed)) ;
   case TK_FM : return ( sToolKey[TK_FM] + "=" + ::ToString( m_dMinFeed)) ;
   case TK_FS : return ( sToolKey[TK_FS] + "=" + ::ToString( m_dStartFeed)) ;
   case TK_FT : return ( sToolKey[TK_FT] + "=" + ::ToString( m_dTipFeed)) ;
   case TK_HEA : return ( sToolKey[TK_HEA] + "=" + m_sHead) ;
   case TK_L : return ( sToolKey[TK_L] + "=" + ::ToString( m_dLen)) ;
   case TK_LT : return ( sToolKey[TK_LT] + "=" + ::ToString( m_dTLen)) ;
   case TK_MM : return ( sToolKey[TK_MM] + "=" + ::ToString( m_dMaxMat)) ;
   case TK_NAME : return ( sToolKey[TK_NAME] + "=" + m_sName) ;
   case TK_NS : return ( sToolKey[TK_NS] + "=" + m_sSysNotes) ;
   case TK_NU : return ( sToolKey[TK_NU] + "=" + m_sUserNotes) ;
   case TK_OL : return ( sToolKey[TK_OL] + "=" + ::ToString( m_dOffsL)) ;
   case TK_OR : return ( sToolKey[TK_OR] + "=" + ::ToString( m_dOffsR)) ;
   case TK_S : return ( sToolKey[TK_S] + "=" + ::ToString( m_dSpeed)) ;
   case TK_SANG : return ( sToolKey[TK_SANG] + "=" + ::ToString( m_dSideAng)) ;
   case TK_SM : return ( sToolKey[TK_SM] + "=" + ::ToString( m_dMaxSpeed)) ;
   case TK_SUP : return ( sToolKey[TK_SUP] + "=" + m_sTcPos) ;
   case TK_TH : return ( sToolKey[TK_TH] + "=" + ::ToString( m_dThick)) ;
   case TK_TYP : return ( sToolKey[TK_TYP] + "=" + ::ToString( m_nType)) ;
   case TK_UUID : return ( sToolKey[TK_UUID] + "=" + ::ToString( m_Uuid)) ;
   default : return "" ;
   }
}

//----------------------------------------------------------------------------
bool
ToolData::VerifySpeed( double dVal) const
{
   return ( abs( dVal) < m_dMaxSpeed + EPS_SMALL) ;
}

//----------------------------------------------------------------------------
bool
ToolData::SetParam( int nType, bool bVal)
{
   switch ( nType) {
   case TPA_ACTIVE :
      return SetValInNotes( TSI_ACTIVE, bVal, m_sSysNotes) ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
ToolData::SetParam( int nType, int nVal)
{
   switch ( nType) {
   case TPA_CORR :
      m_nCorr = nVal ;
      return true ;
   case TPA_EXIT :
      m_nExit = nVal ;
      return true ;
   case TPA_TYPE :
      if ( ! IsValidToolType( nVal))
         return false ;
      m_nType = nVal ;
      return true ;
   case TPA_COOLANT :
      m_nCoolant = nVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
ToolData::SetParam( int nType, double dVal)
{
   switch ( nType) {
   case TPA_CORNRAD :
      m_dCornRad = dVal ;
      return true ;
   case TPA_DIAM :
      m_dDiam = dVal ;
      return true ;
   case TPA_TOTDIAM :
      m_dTDiam = dVal ;
      return true ;
   case TPA_FEED :
      m_dFeed = dVal ;
      return true ;
   case TPA_ENDFEED :
      m_dEndFeed = dVal ;
      return true ;
   case TPA_STARTFEED :
      m_dStartFeed = dVal ;
      return true ;
   case TPA_TIPFEED :
      m_dTipFeed = dVal ;
      return true ;
   case TPA_LEN :
      m_dLen = dVal ;
      return true ;
   case TPA_TOTLEN :
      m_dTLen = dVal ;
      return true ;
   case TPA_MAXMAT :
      m_dMaxMat = dVal ;
      return true ;
   case TPA_LONOFFSET :
      m_dOffsL = dVal ;
      return true ;
   case TPA_RADOFFSET :
      m_dOffsR = dVal ;
      return true ;
   case TPA_SPEED :
      if ( ! VerifySpeed( dVal))
         return false ;
      m_dSpeed = dVal ;
      return true ;
   case TPA_SIDEANG :
      m_dSideAng = dVal ;
      return true ;
   case TPA_MAXSPEED :
      m_dMaxSpeed = dVal ;
      return true ;
   case TPA_THICK :
      m_dThick = dVal ;
      return true ;
   case TPA_MAXABSORPTION :
      m_dMaxAbsorption = dVal ;
      return true ;
   case TPA_MINFEED :
      m_dMinFeed = dVal ;
      return true ;
   case TPA_DIST :
      if ( abs( dVal) > EPS_SMALL)
         SetValInNotes( TSI_DIST, dVal, m_sSysNotes) ;
      else
         RemoveValInNotes( TSI_DIST, m_sSysNotes) ;
      return true ;
   case TPA_STEMDIAM :
      if ( abs( dVal) > EPS_SMALL)
         SetValInNotes( TSI_STEM_DIAM, dVal, m_sSysNotes) ;
      else
         RemoveValInNotes( TSI_STEM_DIAM, m_sSysNotes) ;
      return true ;
   case TPA_CORE :
      if ( abs( dVal) > EPS_SMALL)
         SetValInNotes( TSI_CORE, dVal, m_sSysNotes) ;
      else
         RemoveValInNotes( TSI_CORE, m_sSysNotes) ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
ToolData::SetParam( int nType, const string& sVal)
{
   switch ( nType) {
   case TPA_DRAW :
      m_sDraw = sVal ;
      return true ;
   case TPA_HEAD :
      m_sHead = sVal ;
      return true ;
   case TPA_NAME :
      m_sName = sVal ;
      return true ;
   case TPA_SYSNOTES :
      m_sSysNotes = sVal ;
      return true ;
   case TPA_USERNOTES :
      m_sUserNotes = sVal ;
      return true ;
   case TPA_TCPOS :
      m_sTcPos = sVal ;
      return true ;
   case TPA_UUID :
      return ::FromString( sVal, m_Uuid) ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
ToolData::GetParam( int nType, bool& bVal) const
{
   switch ( nType) {
   case TPA_ACTIVE :
      bVal = false ;
      return GetValInNotes( m_sSysNotes, TSI_ACTIVE, bVal) ;
   }
   bVal = false ;
   return false ;
}

//----------------------------------------------------------------------------
bool
ToolData::GetParam( int nType, int& nVal) const
{
   switch ( nType) {
   case TPA_CORR :
      nVal = m_nCorr ;
      return true ;
   case TPA_EXIT :
      nVal = m_nExit ;
      return true ;
   case TPA_TYPE :
      nVal = m_nType ;
      return true ;
   case TPA_COOLANT :
      nVal = m_nCoolant ;
      return true ;
   }
   nVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
ToolData::GetParam( int nType, double& dVal) const
{
   switch ( nType) {
   case TPA_CORNRAD :
      dVal = m_dCornRad ;
      return true ;
   case TPA_DIAM :
      dVal = m_dDiam ;
      return true ;
   case TPA_TOTDIAM :
      dVal = m_dTDiam ;
      return true ;
   case TPA_FEED :
      dVal = m_dFeed ;
      return true ;
   case TPA_ENDFEED :
      dVal = m_dEndFeed ;
      return true ;
   case TPA_STARTFEED :
      dVal = m_dStartFeed ;
      return true ;
   case TPA_TIPFEED :
      dVal = m_dTipFeed ;
      return true ;
   case TPA_LEN :
      dVal = m_dLen ;
      return true ;
   case TPA_TOTLEN :
      dVal = m_dTLen ;
      return true ;
   case TPA_MAXMAT :
      dVal = m_dMaxMat ;
      return true ;
   case TPA_LONOFFSET :
      dVal = m_dOffsL ;
      return true ;
   case TPA_RADOFFSET :
      dVal = m_dOffsR ;
      return true ;
   case TPA_SPEED :
      dVal = m_dSpeed ;
      return true ;
   case TPA_SIDEANG :
      dVal = m_dSideAng ;
      return true ;
   case TPA_MAXSPEED :
      dVal = m_dMaxSpeed ;
      return true ;
   case TPA_THICK :
      dVal = m_dThick ;
      return true ;
   case TPA_MAXABSORPTION :
      dVal = m_dMaxAbsorption ;
      return true ;
   case TPA_MINFEED :
      dVal = m_dMinFeed ;
      return true ;
   case TPA_DIST :
      dVal = 0 ;
      GetValInNotes( m_sSysNotes, TSI_DIST, dVal) ;
      return true ;
   case TPA_STEMDIAM :
      dVal = 0 ;
      GetValInNotes( m_sSysNotes, TSI_STEM_DIAM, dVal) ;
      return true ;
   case TPA_CORE :
      dVal = 0 ;
      GetValInNotes( m_sSysNotes, TSI_CORE, dVal) ;
      return true ;
   }
   dVal = 0 ;
   return false ;
}

//----------------------------------------------------------------------------
bool
ToolData::GetParam( int nType, string& sVal) const
{
   switch ( nType) {
   case TPA_DRAW :
      sVal = m_sDraw ;
      return true ;
   case TPA_HEAD :
      sVal = m_sHead ;
      return true ;
   case TPA_NAME :
      sVal = m_sName ;
      return true ;
   case TPA_SYSNOTES :
      sVal = m_sSysNotes ;
      return true ;
   case TPA_USERNOTES :
      sVal = m_sUserNotes ;
      return true ;
   case TPA_TCPOS :
      sVal = m_sTcPos ;
      return true ;
   case TPA_UUID :
      sVal = ::ToString( m_Uuid) ;
      return true ;
   }
   sVal = "" ;
   return false ;
}