/*---------------------------------------------------------------------------
  File: VarData.cpp

  Comments: CVarData represents one level in the VarSet.  It has a variant
  value, and a map containing one or more subvalues.

  (c) Copyright 1995-1998, Mission Critical Software, Inc., All Rights Reserved
  Proprietary and confidential to Mission Critical Software, Inc.

  REVISION LOG ENTRY
  Revision By: Christy Boles
  Revised on 11/19/98 17:24:56

 ---------------------------------------------------------------------------
*/

#include "stdafx.h"
#include "VarData.h"
#include "VarMap.h"
#include "DotStr.hpp"

#ifdef STRIPPED_VARSET
   #include "Varset.h"
   #include "NoMcs.h"  
#else
   #include <VarSet.h>
   #include "McString.h"
   #include "McLog.h"
   using namespace McString;
#endif
#include "VSet.h"
#include <comdef.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


int    
   CVarData::SetData(
      CString                key,          // in - key value
      VARIANT              * var,          // in - data value
      BOOL                   bCoerce,      // in - flag, whether to coerce to a persistable value
      HRESULT              * pResult       // out- optional return code
   )
{
   int                       nCreated = 0;
   _variant_t                newVal(var);
   HRESULT                   hr = S_OK;

   if ( key.IsEmpty() )
   {
      m_cs.Lock();
      // set my data value
      if ( ! bCoerce )
      {
         m_var.Copy(&newVal);   
      }
      else
      {
         // need to coerce the value to an appropriate type
      
         if ( var->vt == VT_DISPATCH  || var->vt == VT_UNKNOWN )
         {
            // if it's an IUnknown, see if it supports IDispatch
            IDispatchPtr               pDisp;

            pDisp = newVal;

            if ( pDisp != NULL )
            {
               // the object supports IDispatch
               // try to get the default property
               _variant_t              defPropVar;
               DISPPARAMS              dispParamsNoArgs = {NULL, NULL, 0, 0};

               hr = pDisp->Invoke(0,
                                  IID_NULL,
                                  LOCALE_USER_DEFAULT,
                                  DISPATCH_PROPERTYGET,
                                  &dispParamsNoArgs,
                                  &defPropVar,
                                  NULL,
                                  NULL);
               if ( SUCCEEDED(hr) )
               {
                  // we got the default property
                  newVal = defPropVar;
               }
               else
               {
                  MC_LOG("VarSet::put - unable to retrieve default property for IDispatch object.  Put operation failed, hr=" << hr << "returning E_INVALIDARG");
                  hr = E_INVALIDARG;
               }
            }
         }
         if ( SUCCEEDED(hr) )
         {
            if ( newVal.vt & VT_BYREF )
            {
               if ( newVal.vt == (VT_VARIANT | VT_BYREF) )
               {
                  m_var.Copy(newVal.pvarVal);   
               }
               else
               {
                  hr = ::VariantChangeType(&newVal,&newVal,0,newVal.vt & ~VT_BYREF);
                  if ( SUCCEEDED(hr) )
                  {
                     m_var.Copy(&newVal);   
                  }
                  else
                  {
                     MC_LOG("VarSet::put - failed to dereference variant of type " << newVal.vt << ".  Put operation failed, hr=" <<hr);
                     hr = E_INVALIDARG;
                  }
               }
            }
            else 
            {
               m_var.Copy(&newVal);
            }
         }
      }
      m_cs.Unlock();
   }
   else
   {
      // set the value for a child

      CDottedString          s(key);
      CString                seg;
      CVarData             * pObj;
      CVarData             * pChild;

      s.GetSegment(0,seg);
   
      m_cs.Lock();
      if ( ! m_children )
      {
         // create the child map if it does not exist
         m_children = new CMapStringToVar(IsCaseSensitive(),IsIndexed(), AllowRehashing() );
         if (!m_children)
		 {
            m_cs.Unlock();
            return nCreated;
		 }
      }
      // look for the first segment of the entry in the child map
      if ( ! m_children->Lookup(seg,pObj) )
      {
         // add it if it doesn't exist
         pChild = new CVarData;
         if (!pChild)
		 {
            m_cs.Unlock();
            return nCreated;
		 }
         try {
             pChild->SetCaseSensitive(IsCaseSensitive());
             pChild->SetAllowRehashing(AllowRehashing());
             pChild->SetIndexed(IsIndexed());
             m_children->SetAt(seg,pChild);
             nCreated++; // we added a new node
         }
         catch(...) {
            delete pChild;
            pChild = NULL;
            m_cs.Unlock();
            throw;
         }
      }
      else
      {
         pChild = (CVarData*)pObj;
      }
      // strip off the first segment from the property name, and call SetData
      // recursively on the child item
      nCreated += pChild->SetData(key.Right(key.GetLength() - seg.GetLength()-1),var,bCoerce,&hr);
      m_cs.Unlock();
   }
   if ( pResult )
   {
      (*pResult) = hr;
   }
   return nCreated;
}

void 
   CVarData::RemoveAll()
{
   // remove all children from the map
   m_cs.Lock();
   if ( m_children && ! m_children->IsEmpty() )
   {
      // Enumerate the MAP and delete each object
      POSITION               pos;
      CString                key;
      CVarData             * pObj;

      pos = m_children->GetStartPosition();

      while ( pos )
      {
         m_children->GetNextAssoc(pos,key,pObj);
         if ( pObj )
         {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
            delete pObj;
         }
      }
      m_children->RemoveAll();
   }
   if ( m_children )
   {
      delete m_children;
      m_children = NULL;
   }
   m_cs.Unlock();
}

BOOL                                         // ret- TRUE if key exists in the map
   CVarData::Lookup(
      LPCTSTR                key,            // in - key to search for
      CVarData            *& rValue          // out- value
   ) 
{ 
   if ( m_children ) 
   { 
      return m_children->Lookup(key,rValue); 
   } 
   else 
   {
      return FALSE; 
   }
}

BOOL                                        // ret- TRUE if there are sub-items for this node
   CVarData::HasChildren() 
{ 
   return m_children && !m_children->IsEmpty(); 
}

void 
   CVarData::SetAt(
      LPCTSTR                key,            // in - key 
      CVarData             * newValue        // in - new value
   ) 
{ 
   if ( ! m_children ) 
   { 
      // create map to hold children if it doesn't already exist
      m_children = new CMapStringToVar(IsCaseSensitive(),IsIndexed(),AllowRehashing()); 
      if (!m_children)
         return;
   }
   m_children->SetAt(key,newValue); 
}

void 
   CVarData::SetIndexed(
      BOOL                   nVal
   )
{
   if ( m_children )
   {
      m_children->SetIndexed(nVal);
   }
   if ( nVal )
   {
      m_options |= CVARDATA_INDEXED;
   }
   else
   {
      m_options &= ~CVARDATA_INDEXED;
   }
}
                           
void 
   CVarData::SetCaseSensitive(
      BOOL                   nVal           // in - whether to make lookups case-sensitive
  )
{ 
   if ( m_children ) 
   {
      m_children->SetCaseSensitive(nVal); 
   }
   if ( nVal )
   {
      m_options |= CVARDATA_CASE_SENSITIVE;
   }
   else
   {
      m_options &= ~CVARDATA_CASE_SENSITIVE;
   }
}

void 
   CVarData::SetAllowRehashing(
      BOOL                   nVal           // in - whether to allow the table to be rehashed for better performance
  )
{ 
   if ( m_children ) 
   {
      m_children->SetAllowRehash(nVal); 
   }
   if ( nVal )
   {
      m_options |= CVARDATA_ALLOWREHASH;
   }
   else
   {
      m_options &= ~CVARDATA_ALLOWREHASH;
   }
}




HRESULT 
   CVarData::WriteToStream(
      LPSTREAM               pS            // in - stream to write data to
   )
{
    HRESULT hr = S_OK;
    BOOL     hasChildren = (m_children != NULL);

    // save the variant
    hr = m_var.WriteToStream(pS);

    if (SUCCEEDED(hr) )
    {
        // save children, if any
        ULONG                result;
        hr = pS->Write(&hasChildren,(sizeof hasChildren),&result);
        if ( SUCCEEDED(hr) )
        {
            if ( m_children )
            {
                hr = m_children->WriteToStream(pS);
            }
        }
    }

    return hr;
}

HRESULT 
   CVarData::ReadFromStream(
      LPSTREAM               pS            // in - stream to read data from
   )
{
   HRESULT                   hr = S_OK;
   BOOL                      hasChildren;
   ULONG                     result;

   // read the variant
   hr = m_var.ReadFromStream(pS);
   if ( SUCCEEDED(hr) )
   {
      hr = pS->Read(&hasChildren,(sizeof hasChildren),&result);
      if ( SUCCEEDED(hr) )
      {
         if ( hasChildren )
         {
            // create the child array
            m_children = new CMapStringToVar(IsCaseSensitive(),IsIndexed(),AllowRehashing());
            if (!m_children)
               return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
            hr = m_children->ReadFromStream(pS);
         }
      }

   }
   return hr;
}

DWORD                                      // ret- Length, in bytes to write the data to a stream
   CVarData::CalculateStreamedLength()
{
   HRESULT                   hr =S_OK;
   DWORD                     len = sizeof (VARTYPE);
   
   // Calculate size needed for root data value

   int cbWrite = 0;
	switch (m_var.vt)
	{
	case VT_UNKNOWN:
	case VT_DISPATCH:
	   {
         CComQIPtr<IPersistStream> spStream = m_var.punkVal;
         if( spStream )                
         {
            len += sizeof(CLSID);
            ULARGE_INTEGER  uiSize = { 0 };
            hr = spStream->GetSizeMax(&uiSize);
            if (FAILED(hr))                        
               return hr;
            len += uiSize.LowPart;                
         }            
      }
      break;
   case VT_UI1:
	case VT_I1:
		cbWrite = sizeof(BYTE);
		break;
	case VT_I2:
	case VT_UI2:
	case VT_BOOL:
		cbWrite = sizeof(short);
		break;
	case VT_I4:
	case VT_UI4:
	case VT_R4:
	case VT_INT:
	case VT_UINT:
	case VT_ERROR:
		cbWrite = sizeof(long);
		break;
	case VT_R8:
	case VT_CY:
	case VT_DATE:
		cbWrite = sizeof(double);
		break;
	default:
		break;
	}
	
   CComBSTR bstrWrite;
	CComVariant varBSTR;
	
   if (m_var.vt != VT_BSTR)
	{
		hr = VariantChangeType(&varBSTR, &m_var, VARIANT_NOVALUEPROP, VT_BSTR);
		if (FAILED(hr))
			return hr;
		bstrWrite = varBSTR.bstrVal;
	}
	else
   {
      bstrWrite = m_var.bstrVal;
   }
   len += 4 + (static_cast<BSTR>(bstrWrite) ? SysStringByteLen(bstrWrite) : 0) + 2;
   if ( SUCCEEDED(hr) )
   {
      len += cbWrite;
   }
   
   // Add sizes of children
   len += (sizeof BOOL); // has children?
   if ( m_children )
   {
      len += m_children->CalculateStreamedLength();
   }

   return len;
}

long                                       // ret- number of data items
   CVarData::CountItems()
{
   long                      count = 1;

   if ( m_children )
   {
      count += m_children->CountItems();
   }

   return count;
}

void 
   CVarData::McLogInternalDiagnostics(
      CString                keyname       // in - Key name for this subtree, so the complete name can be displayed
   )
{
   CString value;

   switch ( m_var.vt )
   {
      case VT_EMPTY:      
         value = _T("<Empty>");
         break;
      case VT_NULL:
         value = _T("<Null>");
         break;
      case VT_I2:
      case VT_I4:
         value.Format(_T("%ld"),m_var.iVal);
         break;
      case VT_BSTR:
         value = m_var.bstrVal;
         break;
      default:
         value.Format(_T("variant type=0x%lx"),m_var.vt);
         break;
   }
   MC_LOG(String(keyname) << "-->"<< String(value) << (m_children ? " (Has Children)" : " (No Children)") << " Options = " << makeStr(m_options) << " CaseSensitive=" << ( IsCaseSensitive()?"TRUE":"FALSE") << " Indexed=" << (IsIndexed()?"TRUE":"FALSE") );

   if ( m_children )
   {
      m_children->McLogInternalDiagnostics(keyname);
   }
}