//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : MillingData.cpp       Data : 05.06.15          Versione : 1.6f1
// Contenuto : Implementazione struttura dati lavorazione di fresatura.
//
//
//
// Modifiche : 05.06.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "MillingData.h"
#include "MachiningDataFactory.h"
#include "/EgtDev/Include/EmkToolConst.h"
#include "/EgtDev/Include/EgkGeoConst.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include <array>
#include <cassert>

using namespace std ;

//----------------------------------------------------------------------------
enum nMillingKey {
   KEY_DH = 0,
   KEY_INV,
   KEY_LICL,
   KEY_LIEL,
   KEY_LIPR,
   KEY_LITG,
   KEY_LITY,
   KEY_LOCL,
   KEY_LOEL,
   KEY_LOPR,
   KEY_LOTG,
   KEY_LOTY,
   KEY_LT,
   KEY_NAME,
   KEY_OL,
   KEY_SA,
   KEY_ST,
   KEY_STY,
   KEY_TA,
   KEY_TD,
   KEY_TH,
   KEY_TL,
   KEY_TNAME,
   KEY_TUUID,
   KEY_UUID,
   KEY_WS,
   KEY_ZZZ} ;        // rappresenta il numero di elementi

static const std::array<std::string,KEY_ZZZ> sMillingKey = {
   "DH",
   "INV",
   "LICL",
   "LIEL",
   "LIPR",
   "LITG",
   "LITY",
   "LOCL",
   "LOEL",
   "LOPR",
   "LOTG",
   "LOTY",
   "LT",
   "NAME",
   "OL",
   "SA",
   "ST",
   "STY",
   "TA",
   "TD",
   "TH",
   "TL",
   "TN",
   "TU",
   "UUID",
   "WS"} ;

//----------------------------------------------------------------------------
MCHDATA_REGISTER( MT_MILLING, "MILLING", MillingData) ;

//----------------------------------------------------------------------------
MillingData*
MillingData::Clone( void) const
{
  // alloco oggetto
   MillingData* pMdata = new(nothrow) MillingData ;
  // copio i dati
   if ( pMdata != nullptr) {
      if ( ! pMdata->CopyFrom( this)) {
         delete pMdata ;
         return nullptr ;
      }
   }
   return pMdata ;
}

//----------------------------------------------------------------------------
bool
MillingData::CopyFrom( const MachiningData* pMdata)
{
  // è inutile copiare se sorgente coincide con destinazione
   if ( pMdata == this)
      return true ;
  // la sorgente deve essere dello stesso tipo
   const MillingData* pSdata = dynamic_cast<const MillingData*>( pMdata) ;
   if ( pSdata == nullptr)
      return false ;
  // eseguo copia
   m_Uuid = pSdata->m_Uuid ;
   m_sName = pSdata->m_sName ;
   m_ToolUuid = pSdata->m_ToolUuid ;
   m_sToolName = pSdata->m_sToolName ;
   m_bInvert = pSdata->m_bInvert ;
   m_nWorkSide = pSdata->m_nWorkSide ;
   m_sDepth = pSdata->m_sDepth ;
   m_dOverlap = pSdata->m_dOverlap ;
   m_dStep = pSdata->m_dStep ;
   m_nStepType = pSdata->m_nStepType ;
   m_dSideAngle = pSdata->m_dSideAngle ;
   m_bLeaveTab = pSdata->m_bLeaveTab ;
   m_dTabLen = pSdata->m_dTabLen ;
   m_dTabDist = pSdata->m_dTabDist ;
   m_dTabHeight = pSdata->m_dTabHeight ;
   m_dTabAngle = pSdata->m_dTabAngle ;
   m_nLeadInType = pSdata->m_nLeadInType ;
   m_dLiTang = pSdata->m_dLiTang ;
   m_dLiPerp = pSdata->m_dLiPerp ;
   m_dLiElev = pSdata->m_dLiElev ;
   m_dLiCompLen = pSdata->m_dLiCompLen ;
   m_nLeadOutType = pSdata->m_nLeadOutType ;
   m_dLoTang = pSdata->m_dLoTang ;
   m_dLoPerp = pSdata->m_dLoPerp ;
   m_dLoElev = pSdata->m_dLoElev ;
   m_dLoCompLen = pSdata->m_dLoCompLen ;
   return true ;
}

//----------------------------------------------------------------------------
bool
MillingData::SameAs(const MachiningData* pMdata) const
{
  // se coincide con altro -> uguali
   if ( pMdata == this)
      return true ;
  // se sono di tipo diverso -> diversi
   const MillingData* pSdata = dynamic_cast<const MillingData*>( pMdata) ;
   if ( pSdata == nullptr)
      return false ;
  // confronto termine a termine
   return ( m_Uuid == pSdata->m_Uuid  &&
            m_sName == pSdata->m_sName  &&
            m_ToolUuid == pSdata->m_ToolUuid  &&
            m_sToolName == pSdata->m_sToolName  &&
            m_bInvert == pSdata->m_bInvert  &&
            m_nWorkSide == pSdata->m_nWorkSide  &&
            m_sDepth == pSdata->m_sDepth  &&
            m_dOverlap == pSdata->m_dOverlap  &&
            m_dStep == pSdata->m_dStep  &&
            m_nStepType == pSdata->m_nStepType  &&
            m_dSideAngle == pSdata->m_dSideAngle  &&
            m_bLeaveTab == pSdata->m_bLeaveTab  &&
            m_dTabLen == pSdata->m_dTabLen  &&
            m_dTabDist == pSdata->m_dTabDist  &&
            m_dTabHeight == pSdata->m_dTabHeight  &&
            m_dTabAngle == pSdata->m_dTabAngle  &&
            m_nLeadInType == pSdata->m_nLeadInType  &&
            m_dLiTang == pSdata->m_dLiTang  &&
            m_dLiPerp == pSdata->m_dLiPerp  &&
            m_dLiElev == pSdata->m_dLiElev  &&
            m_dLiCompLen == pSdata->m_dLiCompLen  &&
            m_nLeadOutType == pSdata->m_nLeadOutType  &&
            m_dLoTang == pSdata->m_dLoTang  &&
            m_dLoPerp == pSdata->m_dLoPerp  &&
            m_dLoElev == pSdata->m_dLoElev  &&
            m_dLoCompLen == pSdata->m_dLoCompLen) ;
}

//----------------------------------------------------------------------------
int
MillingData::GetSize( void) const
{
  // in debug verifico validità ultimo campo
   assert( sMillingKey[KEY_WS] == "WS") ;
   return KEY_ZZZ ;
}
//----------------------------------------------------------------------------
string
MillingData::GetTitle( void) const
{
   return MCHDATA_GETNAME( MillingData) ;
}

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

//----------------------------------------------------------------------------
bool
MillingData::FromString( const string& sString, int& nKey)
{
  // separo chiave da valore
   string sKey, sVal ;
   SplitFirst( sString, "=", sKey, sVal) ;
  // riconosco la chiave
   nKey = FindMillingKey( ToUpper( sKey)) ;
   bool bOk = ( nKey >= 0) ;
   switch ( nKey) {
   case KEY_DH :
      m_sDepth = sVal ;
      if ( m_sDepth.empty())
         m_sDepth = "0" ;
      break ;
   case KEY_INV :
      bOk = ::FromString( sVal, m_bInvert) ;
      break ;
   case KEY_LICL :
      bOk = ::FromString( sVal, m_dLiCompLen) ;
      break ;
   case KEY_LIEL :
      bOk = ::FromString( sVal, m_dLiElev) ;
      break ;
   case KEY_LIPR :
      bOk = ::FromString( sVal, m_dLiPerp) ;
      break ;
   case KEY_LITG :
      bOk = ::FromString( sVal, m_dLiTang) ;
      break ;
   case KEY_LITY :
      bOk = ::FromString( sVal, m_nLeadInType) ;
      break ;
   case KEY_LOCL :
      bOk = ::FromString( sVal, m_dLoCompLen) ;
      break ;
   case KEY_LOEL :
      bOk = ::FromString( sVal, m_dLoElev) ;
      break ;
   case KEY_LOPR :
      bOk = ::FromString( sVal, m_dLoPerp) ;
      break ;
   case KEY_LOTG :
      bOk = ::FromString( sVal, m_dLoTang) ;
      break ;
   case KEY_LOTY :
      bOk = ::FromString( sVal, m_nLeadOutType) ;
      break ;
   case KEY_LT :
      bOk = ::FromString( sVal, m_bLeaveTab) ;
      break ;
   case KEY_NAME :
      m_sName = sVal ;
      bOk = ! m_sName.empty() ;
      break ;
   case KEY_OL :
      bOk = ::FromString( sVal, m_dOverlap) ;
      break ;
   case KEY_SA :
      bOk = ::FromString( sVal, m_dSideAngle) ;
      break ;
   case KEY_ST :
      bOk = ::FromString( sVal, m_dStep) ;
      break ;
   case KEY_STY :
      bOk = ::FromString( sVal, m_nStepType) ;
      break ;
   case KEY_TA :
      bOk = ::FromString( sVal, m_dTabAngle) ;
      break ;
   case KEY_TD :
      bOk = ::FromString( sVal, m_dTabDist) ;
      break ;
   case KEY_TH :
      bOk = ::FromString( sVal, m_dTabHeight) ;
      break ;
   case KEY_TL :
      bOk = ::FromString( sVal, m_dTabLen) ;
      break ;
   case KEY_TNAME :
      m_sToolName = sVal ;
      break ;
   case KEY_TUUID :
      bOk = ::FromString( sVal, m_ToolUuid) ;
      break ;
   case KEY_UUID :
      bOk = ::FromString( sVal, m_Uuid) ;
      break ;
   case KEY_WS :
      bOk = ::FromString( sVal, m_nWorkSide) ;
      break ;
   default :
      bOk = false ;
      break ;
   }
   return bOk ;
}

//----------------------------------------------------------------------------
string
MillingData::ToString( int nInd) const
{
   switch ( nInd) {
   case KEY_DH : return ( sMillingKey[KEY_DH] + "=" +  m_sDepth) ;
   case KEY_INV : return ( sMillingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
   case KEY_LICL : return ( sMillingKey[KEY_LICL] + "=" + ::ToString( m_dLiCompLen)) ;
   case KEY_LIEL : return ( sMillingKey[KEY_LIEL] + "=" + ::ToString( m_dLiElev)) ;
   case KEY_LIPR : return ( sMillingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ;
   case KEY_LITG : return ( sMillingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ;
   case KEY_LITY : return ( sMillingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ;
   case KEY_LOCL : return ( sMillingKey[KEY_LOCL] + "=" + ::ToString( m_dLoCompLen)) ;
   case KEY_LOEL : return ( sMillingKey[KEY_LOEL] + "=" + ::ToString( m_dLoElev)) ;
   case KEY_LOPR : return ( sMillingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ;
   case KEY_LOTG : return ( sMillingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ;
   case KEY_LOTY : return ( sMillingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ;
   case KEY_LT : return ( sMillingKey[KEY_LT] + "=" + ::ToString( m_bLeaveTab)) ;
   case KEY_NAME : return ( sMillingKey[KEY_NAME] + "=" + m_sName) ;
   case KEY_OL : return ( sMillingKey[KEY_OL] + "=" + ::ToString( m_dOverlap)) ;
   case KEY_SA : return ( sMillingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ;
   case KEY_ST : return ( sMillingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ;
   case KEY_STY : return ( sMillingKey[KEY_STY] + "=" + ::ToString( m_nStepType)) ;
   case KEY_TA : return ( sMillingKey[KEY_TA] + "=" + ::ToString( m_dTabAngle)) ;
   case KEY_TD : return ( sMillingKey[KEY_TD] + "=" + ::ToString( m_dTabDist)) ;
   case KEY_TH : return ( sMillingKey[KEY_TH] + "=" + ::ToString( m_dTabHeight)) ;
   case KEY_TL : return ( sMillingKey[KEY_TL] + "=" + ::ToString( m_dTabLen)) ;
   case KEY_TNAME : return ( sMillingKey[KEY_TNAME] + "=" + m_sToolName) ;
   case KEY_TUUID : return ( sMillingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
   case KEY_UUID : return ( sMillingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
   case KEY_WS : return ( sMillingKey[KEY_WS] + "=" + ::ToString( m_nWorkSide)) ;
   default : return "" ;
   }
}

//----------------------------------------------------------------------------
bool
MillingData::VerifyWorkSide( int nVal) const
{
   return ( nVal == MILL_WS_CENTER  ||  nVal == MILL_WS_LEFT  ||  nVal == MILL_WS_RIGHT) ;
}

//----------------------------------------------------------------------------
bool
MillingData::VerifyStepType( int nVal) const
{
   return ( nVal == MILL_ST_STEP  ||  nVal == MILL_ST_ONEWAY  ||  nVal == MILL_ST_SPIRAL) ;
}

//----------------------------------------------------------------------------
bool
MillingData::VerifyLeadInType( int nVal) const
{
   return ( nVal == MILL_LI_NONE  ||  nVal == MILL_LI_LINEAR  ||
            nVal == MILL_LI_TANGENT  ||  nVal == MILL_LI_GLIDE) ;
}

//----------------------------------------------------------------------------
bool
MillingData::VerifyLeadOutType( int nVal) const
{
   return ( nVal == MILL_LO_NONE  ||  nVal == MILL_LO_LINEAR  ||
            nVal == MILL_LO_TANGENT  ||  nVal == MILL_LO_GLIDE  ||  nVal == MILL_LO_AS_LI) ;
}

//----------------------------------------------------------------------------
bool
MillingData::VerifySideAngle( double dVal) const
{
   return ( ( dVal > - EPS_SMALL  &&  dVal < 90 + EPS_SMALL)  ||  fabs( dVal - 99) < EPS_SMALL) ;
}

//----------------------------------------------------------------------------
bool
MillingData::VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const
{
   if ( pToolsMgr == nullptr)
      return false ;
   pTdata =  pToolsMgr->GetTool( sVal) ;
   if ( pTdata == nullptr)
      return false ;
   if ( ( pTdata->m_nType & TF_MILL) == 0  &&  ( pTdata->m_nType & TF_SAWBLADE) == 0)
      return false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
MillingData::SetParam( int nType, bool bVal)
{
   switch ( nType) {
   case MPA_INVERT :
      m_bInvert = bVal ;
      return true ;
   case MPA_LEAVETAB  :
      m_bLeaveTab = bVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MillingData::SetParam( int nType, int nVal)
{
   switch ( nType) {
   case MPA_WORKSIDE :
      if ( ! VerifyWorkSide( nVal))
         return false ;
      m_nWorkSide = nVal ;
      return true ;
   case MPA_STEPTYPE :
      if ( ! VerifyStepType( nVal))
         return false ;
      m_nStepType = nVal ;
      return true ;
   case MPA_LEADINTYPE :
      if ( ! VerifyLeadInType( nVal))
         return false ;
      m_nLeadInType = nVal ;
      return true ;
   case MPA_LEADOUTTYPE :
      if ( ! VerifyLeadOutType( nVal))
         return false ;
      m_nLeadOutType = nVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MillingData::SetParam( int nType, double dVal)
{
   switch ( nType) {
   case MPA_DEPTH :
      m_sDepth = ::ToString( dVal) ;
      return true ;
   case MPA_OVERLAP :
      m_dOverlap = dVal ;
      return true ;
   case MPA_STEP :
      m_dStep = dVal ;
      return true ;
   case MPA_SIDEANGLE :
      if ( ! VerifySideAngle( dVal))
         return false ;
      m_dSideAngle = dVal ;
      return true ;
   case MPA_TABLEN :
      m_dTabLen = dVal ;
      return true ;
   case MPA_TABDIST :
      m_dTabDist = dVal ;
      return true ;
   case MPA_TABHEIGHT :
      m_dTabHeight = dVal ;
      return true ;
   case MPA_TABANGLE :
      m_dTabAngle = dVal ;
      return true ;
   case MPA_LITANG :
      m_dLiTang = dVal ;
      return true ;
   case MPA_LIPERP :
      m_dLiPerp = dVal ;
      return true ;
   case MPA_LIELEV :
      m_dLiElev = dVal ;
      return true ;
   case MPA_LICOMPLEN :
      m_dLiCompLen = dVal ;
      return true ;
   case MPA_LOTANG :
      m_dLoTang = dVal ;
      return true ;
   case MPA_LOPERP :
      m_dLoPerp = dVal ;
      return true ;
   case MPA_LOELEV :
      m_dLoElev = dVal ;
      return true ;
   case MPA_LOCOMPLEN :
      m_dLoCompLen = dVal ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MillingData::SetParam( int nType, const string& sVal)
{
   switch ( nType) {
   case MPA_NAME :
      m_sName = sVal ;
      return true ;
   case MPA_TOOL :
      m_sToolName = sVal ;
      return true ;
   case MPA_DEPTH_STR :
      m_sDepth = sVal ;
      return true ;
   case MPA_TUUID :
      return ::FromString( sVal, m_ToolUuid) ;
   case MPA_UUID :
      return ::FromString( sVal, m_Uuid) ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MillingData::GetParam( int nType, bool& bVal) const
{
   switch ( nType) {
   case MPA_INVERT :
      bVal = m_bInvert ;
      return true ;
   case MPA_LEAVETAB  :
      bVal = m_bLeaveTab ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MillingData::GetParam( int nType, int& nVal) const
{
   switch ( nType) {
   case MPA_WORKSIDE :
      nVal = m_nWorkSide ;
      return true ;
   case MPA_STEPTYPE :
      nVal = m_nStepType ;
      return true ;
   case MPA_LEADINTYPE :
      nVal = m_nLeadInType ;
      return true ;
   case MPA_LEADOUTTYPE :
      nVal = m_nLeadOutType ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MillingData::GetParam( int nType, double& dVal) const
{
   switch ( nType) {
   case MPA_OVERLAP :
      dVal = m_dOverlap ;
      return true ;
   case MPA_STEP :
      dVal = m_dStep ;
      return true ;
   case MPA_SIDEANGLE :
      dVal = m_dSideAngle ;
      return true ;
   case MPA_TABLEN :
      dVal = m_dTabLen ;
      return true ;
   case MPA_TABDIST :
      dVal = m_dTabDist ;
      return true ;
   case MPA_TABHEIGHT :
      dVal = m_dTabHeight ;
      return true ;
   case MPA_TABANGLE :
      dVal = m_dTabAngle ;
      return true ;
   case MPA_LITANG :
      dVal = m_dLiTang ;
      return true ;
   case MPA_LIPERP :
      dVal = m_dLiPerp ;
      return true ;
   case MPA_LIELEV :
      dVal = m_dLiElev ;
      return true ;
   case MPA_LICOMPLEN :
      dVal = m_dLiCompLen ;
      return true ;
   case MPA_LOTANG :
      dVal = m_dLoTang ;
      return true ;
   case MPA_LOPERP :
      dVal = m_dLoPerp ;
      return true ;
   case MPA_LOELEV :
      dVal = m_dLoElev ;
      return true ;
   case MPA_LOCOMPLEN :
      dVal = m_dLoCompLen ;
      return true ;
   }
   return false ;
}

//----------------------------------------------------------------------------
bool
MillingData::GetParam( int nType, string& sVal) const
{
   switch ( nType) {
   case MPA_NAME :
      sVal = m_sName ;
      return true ;
   case MPA_TOOL :
      sVal = m_sToolName ;
      return true ;
   case MPA_DEPTH_STR :
      sVal = m_sDepth ;
      return true ;
   case MPA_TUUID :
      sVal = ::ToString( m_ToolUuid) ;
      return true ;
   case MPA_UUID :
      sVal = ::ToString( m_Uuid) ;
      return true ;
   }
   return false ;
}