// ####ECOSHOSTGPLCOPYRIGHTBEGIN####                                        
// -------------------------------------------                              
// This file is part of the eCos host tools.                                
// Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.            
//
// This program is free software; you can redistribute it and/or modify     
// it under the terms of the GNU General Public License as published by     
// the Free Software Foundation; either version 2 or (at your option) any   
// later version.                                                           
//
// This program is distributed in the hope that it will be useful, but      
// WITHOUT ANY WARRANTY; without even the implied warranty of               
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        
// General Public License for more details.                                 
//
// You should have received a copy of the GNU General Public License        
// along with this program; if not, write to the                            
// Free Software Foundation, Inc., 51 Franklin Street,                      
// Fifth Floor, Boston, MA  02110-1301, USA.                                
// -------------------------------------------                              
// ####ECOSHOSTGPLCOPYRIGHTEND####                                          
//
//===========================================================================
//===========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s): 	sdf
// Contact(s):	sdf
// Date:		1998/08/11
// Version:		0.01
// Purpose:	
// Description:	This is the implementation of the configuration item class
// Requires:	
// Provides:	
// See also:    
// Known bugs:	
// Usage:	
//
//####DESCRIPTIONEND####
//
//===========================================================================
#include "stdafx.h"
#include "ConfigItem.h"
#include "ControlView.h"
#include "CTUtils.h"
#ifdef PLUGIN
  #define INCLUDEFILE "ide.common.h" // for setEditLocation
  #include "IncludeSTL.h"
  #include "common/CodeCoordinate.h"
#endif
#include "ConfigToolDoc.h"
#include "ConfigTool.h"

LPCTSTR CConfigItem::TreeItemTypeImage[MaxTreeItemType + 1]={
  _T("None"), _T("Integer"), _T("Enumeration"), _T("String"), _T("Double"), 0}; // Internationalization OK

const CFileName CConfigItem::FileName() const
{
  CFileName strFile;
  const CdlNode node = dynamic_cast<CdlNode> (m_CdlItem);
  if (node){
    // get the package which owns the configuration item
    const CdlPackage package = GetOwnerPackage();
    if (package){
      
      // return the filename of the config header
      strFile=CFileName(CConfigTool::GetConfigToolDoc()->InstallTree()+_T("include\\pkgconf"))+package->get_config_header ().c_str ();
    }
  }
  return strFile;
}

CConfigItem::CConfigItem(CConfigItem *pParent, CdlUserVisible CdlItem):
  m_CdlItem(CdlItem)
{
  CTreeCtrl &tree=CConfigTool::GetControlView()->GetTreeCtrl();
  HTREEITEM hParent;
  if(NULL==CdlItem){
    // This is the root item
    hParent=TVI_ROOT;
    m_Type=None;
  } else {
    hParent=pParent->HItem();
  
    // FIXME: re-implement using CdlValuableBody::get_widget_hint()
    if (IsPackage()) {
      // If a package item, display the package version string
      m_Type=String; 
    } else {
      const CdlValuable valuable = dynamic_cast<CdlValuable> (CdlItem);
      switch (valuable->get_flavor ()){
        case CdlValueFlavor_None:
        case CdlValueFlavor_Bool:
          m_Type=None;
          break;
        case CdlValueFlavor_Data:
        case CdlValueFlavor_BoolData:
          if (! valuable->has_legal_values ()) {
            m_Type=String;
          } else if (0 == valuable->get_legal_values ()->ranges.size ()) {
            m_Type=Enum;
          } else {
            CdlListValue list_value;
            CdlEvalContext context (NULL, valuable, valuable->get_property (CdlPropertyId_LegalValues));
            valuable->get_legal_values ()->eval (context, list_value);
            m_Type=list_value.get_double_ranges ().size () ? Double : Integer;
          }
          break;
        default:
          ASSERT (0); // specified flavor not supported
          break;
      }
    }  
  }
  m_hItem=tree.InsertItem(ItemNameOrMacro(),hParent);
  tree.SetItemData(m_hItem,(DWORD)this);
  CConfigTool::GetControlView()->AdjustItemImage(m_hItem);
}

CConfigItem::~CConfigItem()
{
}

CString CConfigItem::GetURL() const
{
  for(const CConfigItem *pItem=this;pItem;pItem=pItem->Parent()){
    if(pItem->GetCdlItem()){
      CString strURL;
      strURL=pItem->GetCdlItem()->get_doc_url().c_str();
      if(strURL.GetLength()){
        return strURL;
      }
      strURL=pItem->GetCdlItem()->get_doc().c_str();
      if(strURL.GetLength()){
        return strURL;
      }
    }
  }
  return _T("ref/ecos-ref.html"); // the default URL
}

bool CConfigItem::SetValue(LPCTSTR pszValue, CdlTransaction transaction/*=NULL*/)
{
  ASSERT ((m_Type == String) || (m_Type == Enum));
  const CdlValuable valuable = GetCdlValuable();
  ASSERT (valuable);
  const std::string str=CUtils::UnicodeToStdStr (pszValue);
  if(transaction){
    if (CdlValueFlavor_BoolData == valuable->get_flavor ()){
      // set the user bool to the current bool when changing a booldata
      // value to avoid a possible change in the current bool
      valuable->set_enabled_and_value (transaction, valuable->is_enabled (), str, CdlValueSource_User);
    } else {// CdlValueFlavor_Data
      valuable->set_value (transaction, str, CdlValueSource_User);
    }
  } else {
    if (CdlValueFlavor_BoolData == valuable->get_flavor ()){
      // set the user bool to the current bool when changing a booldata
      // value to avoid a possible change in the current bool
      valuable->set_enabled_and_value (valuable->is_enabled (), str, CdlValueSource_User);
    } else {// CdlValueFlavor_Data
      valuable->set_value (str, CdlValueSource_User);
    }
  }
  
  return true;
}

bool CConfigItem::SetValue (double dValue, CdlTransaction transaction/*=NULL*/)
{
  ASSERT (m_Type == Double);
  const CdlValuable valuable = GetCdlValuable();
  ASSERT (valuable);
  
  if(transaction) {
    if (CdlValueFlavor_BoolData == valuable->get_flavor ()) {
      // set the user bool to the current bool when changing a booldata
      // value to avoid a possible change in the current bool
      valuable->set_enabled_and_value (transaction, valuable->is_enabled (), dValue, CdlValueSource_User);
    } else {// CdlValueFlavor_Data
      valuable->set_double_value (transaction, dValue, CdlValueSource_User);
    }
  } else {
    if (CdlValueFlavor_BoolData == valuable->get_flavor ()) {
      // set the user bool to the current bool when changing a booldata
      // value to avoid a possible change in the current bool
      valuable->set_enabled_and_value (valuable->is_enabled (), dValue, CdlValueSource_User);
    } else {// CdlValueFlavor_Data
      valuable->set_double_value (dValue, CdlValueSource_User);
    }
  }
  
  return true;
}

CConfigItem *CConfigItem::FirstRadio() const
{
  ASSERT(HasRadio ());
  
  for(CConfigItem *h=Parent()->FirstChild();h;h=h->NextSibling()){
    if(h->HasRadio ()){
      return h;
    }
  }
  // No radio buttons found
  ASSERT(false);
  return false;
}

bool CConfigItem::IsEnabled() const
{
  const CdlValuable valuable = GetCdlValuable();
  return NULL==valuable ||valuable->is_enabled();
}

bool CConfigItem::SetValue (ItemIntegerType nValue, CdlTransaction transaction/*=NULL*/)
{
  ASSERT (m_Type == Integer);
  const CdlValuable valuable = GetCdlValuable();
  ASSERT (valuable);

  if(transaction) {
    if (CdlValueFlavor_BoolData == valuable->get_flavor ()) {
      // set the user bool to the current bool when changing a booldata
      // value to avoid a possible change in the current bool
      valuable->set_enabled_and_value (transaction, valuable->is_enabled (), (cdl_int) nValue, CdlValueSource_User);
    } else { // CdlValueFlavor_Data
      valuable->set_integer_value (transaction, nValue, CdlValueSource_User);
    }
  } else {
    if (CdlValueFlavor_BoolData == valuable->get_flavor ()) {
      // set the user bool to the current bool when changing a booldata
      // value to avoid a possible change in the current bool
      valuable->set_enabled_and_value (valuable->is_enabled (), (cdl_int) nValue, CdlValueSource_User);
    } else { // CdlValueFlavor_Data
      valuable->set_integer_value (nValue, CdlValueSource_User);
    }
  }
  
  return true;
}

bool CConfigItem::HasModifiedChildren() const
{
  for(CConfigItem *pItem=FirstChild();pItem;pItem=pItem->NextSibling()){
    if(pItem->Modified()||pItem->HasModifiedChildren()){
      return true;
    }
  }
  return false;
}

ItemIntegerType CConfigItem::Value () const
{
  ASSERT (!IsPackage()); // not a package item
  const CdlValuable valuable = GetCdlValuable();
  ASSERT (valuable);
  ItemIntegerType nValue (0);
  
  switch (valuable->get_flavor ())
  {
    //	case CdlValueFlavor_Bool:
    //		nValue = valuable->is_enabled (CdlValueSource_Current) ? 1 : 0;
    //		break;
    
  case CdlValueFlavor_BoolData:
  case CdlValueFlavor_Data:
    nValue = (ItemIntegerType) valuable->get_integer_value (CdlValueSource_Current);
    break;
    
  default:
    ASSERT (0); // specified flavor not supported
  }
  
  return nValue;
}

const double CConfigItem::DoubleValue (CdlValueSource source /* = CdlValueSource_Current */ ) const
{
  ASSERT (!IsPackage()); // not a package item
  const CdlValuable valuable = GetCdlValuable();
  ASSERT (valuable);
  ASSERT (valuable->has_double_value (source));
  return valuable->get_double_value (source);
}

ItemIntegerType CConfigItem::DefaultValue () const
{
  ItemIntegerType nValue;
  return CUtils::StrToItemIntegerType (StringValue (CdlValueSource_Default), nValue) ? nValue : 0;
}

const CString CConfigItem::StringValue (CdlValueSource source /* = CdlValueSource_Current */ ) const
{
  //	ASSERT (!IsPackage()); // not a package item
  const CdlValuable valuable = GetCdlValuable();
  ASSERT (valuable);
  CString strValue (_T(""));
  
  switch (valuable->get_flavor ())
  {
    case CdlValueFlavor_Data:
    case CdlValueFlavor_BoolData:
    case CdlValueFlavor_None: // a package
      if (m_Type == Integer)
        strValue = CUtils::IntToStr (Value (), CConfigTool::GetConfigToolDoc ()->m_bHex);
      else if (m_Type == Double)
        strValue = CUtils::DoubleToStr (DoubleValue ());
      else
        strValue = valuable->get_value (source).c_str ();
      break;
    
    default:
      ASSERT (0); // specified flavor not supported
  }
  
  return strValue;
}

const CString CConfigItem::StringValue(WhereType where) const
{
  CString str;
  switch(where){
    case InName:
      str=Name();
      break;
    case InMacro:
      str=Macro();
      break;
    case InDesc:
      str=Desc();
      break;
    case InCurrentValue:
      str=CConfigItem::None==Type()?_T(""):StringValue(CdlValueSource_Current);
      break;
    case InDefaultValue:
      str=CConfigItem::None==Type()?_T(""):StringValue(CdlValueSource_Default);
      break;
    default:
      ASSERT(FALSE);
      break;
  }
  return str;
}    

void CConfigItem::DumpItem()
{
  TRACE(_T("Item %08x\n\tDisplay Name='%s'\n\tMacro Name='%s'\n\tType=%s"),
    this,	Name(),           Macro(),    TreeItemTypeImage[m_Type]);
  TRACE(_T("\n\tValue=%s\n\tURL=%s\n\tParent=%08x"),StringValue(), GetURL(), Parent());
  
  TRACE(_T("\n"));
}

CConfigItem * CConfigItem::NextRadio() const
{
  ASSERT(this->HasRadio ());
  for(CConfigItem *pItem=NextSibling();pItem;pItem=pItem->NextSibling()){
    if(pItem->HasRadio()){
      return pItem;
    }
  }
  return NULL;
}

bool CConfigItem::Modified () const
{
  const CdlValuable valuable = GetCdlValuable();
  return 
    valuable        // accommodate the root config item which has no CDL item
    && !IsPackage() // packages are never modified
    && valuable->get_source () != CdlValueSource_Default;
}

CString CConfigItem::ItemNameOrMacro() const
{
  CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
  return pDoc->m_bMacroNames&&!Macro().IsEmpty()?Macro():Name();
}

bool CConfigItem::IsDescendantOf(CConfigItem * pAncestor)
{
  for(CConfigItem *pItem=Parent();pItem;pItem=pItem->Parent()){
    if(pItem==pAncestor){
      return true;
    }
  }
  return false;
}

int CConfigItem::EvalEnumStrings (CStringArray &arEnumStrings) const
{
  const CdlValuable valuable = GetCdlValuable();
  ASSERT (valuable);
  /*
  if (m_Type == Boolean)
  {
  arEnumStrings.SetSize (2);
  arEnumStrings.SetAt (0, _T("True"));
  arEnumStrings.SetAt (1, _T("False"));
  }
  else
  */
  {
    ASSERT (m_Type == Enum);
    CdlListValue list_value;
    CdlEvalContext context (NULL, m_CdlItem, m_CdlItem->get_property (CdlPropertyId_LegalValues));
    valuable->get_legal_values ()->eval (context, list_value);
    const std::vector<CdlSimpleValue> & table = list_value.get_table ();
    
    // add legal values to the list
    arEnumStrings.SetSize (table.size ());
    for (unsigned int nValue = 0; nValue < table.size (); nValue++)
    {
      arEnumStrings.SetAt (nValue, table [nValue].get_value ().c_str ());
    }
  }
  return arEnumStrings.GetSize();
}

bool CConfigItem::HasBool() const
{
  if (!m_CdlItem) {
    return false;
  } else if (IsPackage()) {
    return false;
  } else {
    const CdlValuable valuable = GetCdlValuable();
    CdlValueFlavor flavor = valuable->get_flavor ();
    return (flavor == CdlValueFlavor_Bool) || (flavor == CdlValueFlavor_BoolData);
  }
}

bool CConfigItem::HasRadio() const
{
  const CdlValuable valuable = GetCdlValuable();
  if (! valuable)
    return false;
  
  CdlWidgetHint hint;
  valuable->get_widget_hint (hint);
  return (CdlBoolWidget_Radio == hint.bool_widget);
}

bool CConfigItem::SetEnabled(bool bEnabled, CdlTransaction current_transaction/*=NULL*/)
{
  const CdlValuable valuable = GetCdlValuable();
  ASSERT (valuable);
  
  // use a transaction object to ensure that all config items are changed together
  CdlTransaction transaction = current_transaction ? current_transaction : CdlTransactionBody::make (CConfigTool::GetConfigToolDoc ()->GetCdlConfig ());
  
  if (HasRadio () && bEnabled) { // if a new radio button has been selected
    for (CConfigItem *pItem = FirstRadio(); pItem; pItem = pItem->NextRadio ()) { // for each radio button in the group
      if (pItem != this) { // if not the newly selected radio button
        pItem->SetEnabled (false, transaction); // disable the radio button
      }
    }
  }
  
  if (CdlValueFlavor_BoolData == valuable->get_flavor ()) {
    // set the user value to the current data value when enabling/disabling
    // a booldata item to avoid a possible change in the current data value
    CdlSimpleValue simple_value = valuable->get_simple_value ();
    valuable->set_enabled_and_value (transaction, bEnabled, simple_value, CdlValueSource_User);
  } else { // CdlValueFlavor_Bool
    valuable->set_enabled (transaction, bEnabled, CdlValueSource_User);
  }
  
  if (! current_transaction) { // if not a recursive call to disable a radio button
    transaction->body (); // commit the transaction
    deleteZ(transaction);
  }
  
  return true;
}

bool CConfigItem::ViewHeader()
{
  bool rc=false;
  const CFileName strFile(FileName());
  if(!strFile.IsEmpty()){
    CConfigToolDoc *pDoc=CConfigTool::GetConfigToolDoc();
    if(pDoc->BuildTree().IsEmpty()){
      CUtils::MessageBoxF(_T("Cannot display header file until configuration is saved"));
    } else {
#ifdef PLUGIN
      // Load or activate window and leave
      CodeCoordinate loc((LPCTSTR)strFile, 0, 0, CodeCoordinate::FILE_LINE);
      rc=AppInstance::getAppManager()->getEditorController()->setEditLocation(loc);
#else
      rc=CUtils::Launch(strFile,pDoc->m_strViewer);
#endif
    }
  }
  return rc;
}

bool CConfigItem::ViewURL()
{
  return CConfigTool::GetConfigToolDoc()->ShowURL(GetURL());
}

// Unload (a package)
bool CConfigItem::Unload()
{
  bool rc=false;
  CdlPackage package=dynamic_cast<CdlPackage>(GetCdlItem());
  ASSERT(package);
  CConfigToolDoc* pDoc=CConfigTool::GetConfigToolDoc();
  // Remove its objects from the view to prevent any painting problems
  CConfigTool::GetControlView()->GetTreeCtrl().DeleteItem(HItem());
  for(int nItem=0;nItem<pDoc->ItemCount();nItem++){
    CConfigItem *pItem=pDoc->Item(nItem);
    if(package==pItem->GetOwnerPackage()){
      //CConfigTool::GetControlView()->GetTreeCtrl().DeleteItem(pItem->HItem());
      pItem->m_hItem=NULL;   // Make sure we can't attempt to paint it
      pItem->m_CdlItem=NULL; // Make sure we can't access stale data
    }
  }
  
  const CString strMacroName(Macro());
  TRACE (_T("Unloading package %s\n"), strMacroName);
  try {
    pDoc->GetCdlConfig()->unload_package (package);
    rc=true;
  }
  catch (CdlStringException exception) {
    CUtils::MessageBoxF(_T("Error unloading package %s:\n\n%s"), strMacroName, CString (exception.get_message ().c_str ()));
  }
  catch (...) {
    CUtils::MessageBoxF(_T("Error unloading package %s"), strMacroName);
  }
  m_hItem=NULL;   // Make sure we can't attempt to paint it
  m_CdlItem=NULL; // Make sure we can't access stale data
  return rc;
}

// Change version (of a package)
bool CConfigItem::ChangeVersion(const CString &strVersion)
{
  bool rc=false;
  CdlPackage package=dynamic_cast<CdlPackage>(GetCdlItem());
  ASSERT(package);
  const CdlValuable valuable = GetCdlValuable();
  ASSERT (valuable);
  const CString strMacroName(Macro());
  if (strVersion != valuable->get_value ().c_str ()) { // if the wrong version is loaded
    TRACE (_T("Changing package %s to version '%s'\n"), strMacroName, strVersion);
    try {
      CConfigTool::GetConfigToolDoc()->GetCdlConfig()->change_package_version (package, CUtils::UnicodeToStdStr (strVersion), CConfigToolDoc::CdlParseErrorHandler, CConfigToolDoc::CdlParseWarningHandler);
      rc=true;
    }
    catch (CdlStringException exception) {
      CUtils::MessageBoxF(_T("Error changing package %s to version '%s':\n\n%s"), strMacroName, strVersion, CString (exception.get_message ().c_str ()));
    }
    catch (...) {
      CUtils::MessageBoxF(_T("Error changing package %s to version '%s'"), strMacroName, strVersion);
    }
  }
  return rc;
}

CConfigItem *CConfigItem::Parent() const 
{ 
  CTreeCtrl &tree=CConfigTool::GetControlView()->GetTreeCtrl();
  HTREEITEM hParent=tree.GetParentItem(HItem());
  return (NULL==hParent||TVI_ROOT==hParent)?NULL:(CConfigItem *)tree.GetItemData(hParent);
}

CConfigItem *CConfigItem::FirstChild() const
{ 
  CTreeCtrl &tree=CConfigTool::GetControlView()->GetTreeCtrl();
  HTREEITEM hChild=tree.GetChildItem(HItem());
  return hChild?(CConfigItem *)tree.GetItemData(hChild):NULL;
}

CConfigItem *CConfigItem::NextSibling() const
{ 
  CTreeCtrl &tree=CConfigTool::GetControlView()->GetTreeCtrl();
  HTREEITEM hSibling=tree.GetNextSiblingItem(HItem());
  return hSibling?(CConfigItem *)tree.GetItemData(hSibling):NULL;
}
