/*	-*- C++ -*-
 * Copyright (C) 2001-2003, Christof Meerwald
 * http://JabXPCOM.sunsite.dk
 */

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public License
 * as published by the Free Software Foundation; version 2 dated June,
 * 1991.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 * USA
 */

#include "judoxpcom-wrapper.h"

#include <string>
#include <vector>

#include <nsCOMPtr.h>
#include <nsMemory.h>
#include <nsString.h>


NS_IMPL_ISUPPORTS1(Judo_Node_Wrapper, judoINode)


Judo_Node_Wrapper::Judo_Node_Wrapper(const judo::Node *node)
  : node_(node)
{
  NS_INIT_ISUPPORTS();

  /* member initializers and constructor code */
#ifdef JABXPCOM_DEBUG
  printf("constructing Judo_Node_Wrapper()\n");
#endif
}

Judo_Node_Wrapper::~Judo_Node_Wrapper()
{
  /* destructor code */
#ifdef JABXPCOM_DEBUG
  printf("deleting Judo_Node_Wrapper()\n");
#endif
}


/* readonly attribute NodeType type; */
NS_IMETHODIMP Judo_Node_Wrapper::GetType(NodeType *aType)
{
  *aType = node_->getType();

  return NS_OK;
}

/* readonly attribute string name; */
NS_IMETHODIMP Judo_Node_Wrapper::GetName(nsACString &aName)
{
  const std::string &name = node_->getName();
  aName.Assign(name.data(), name.length());

  return NS_OK;
}

/* string toXML (); */
NS_IMETHODIMP Judo_Node_Wrapper::ToXML(nsACString &_retval)
{
  const std::string xml = node_->toString();
  _retval.Assign(xml.data(), xml.length());

  return NS_OK;
}


NS_IMPL_ISUPPORTS_INHERITED1(Judo_ConstElement_Wrapper,
			     Judo_Node_Wrapper,
			     judoIConstElement)

Judo_ConstElement_Wrapper::Judo_ConstElement_Wrapper(const judo::Element *element)
  : Judo_Node_Wrapper(element),
    element_(element), managed_object_(false)
{
  /* member initializers and constructor code */
#ifdef JABXPCOM_DEBUG
  printf("constructing Judo_ConstElement_Wrapper(%d)\n", managed_object_);
#endif
}

Judo_ConstElement_Wrapper::~Judo_ConstElement_Wrapper()
{
  /* destructor code */
#ifdef JABXPCOM_DEBUG
  printf("deleting Judo_ConstElement_Wrapper(%d)\n", managed_object_);
#endif

  if (managed_object_)
  {
    delete element_;
  }
}

/* string getAttrib (in string name); */
NS_IMETHODIMP Judo_ConstElement_Wrapper::GetAttrib(const nsACString &name,
						   nsACString &_retval)
{
  const std::string attrib =
    element_->getAttrib(PromiseFlatCString(name).get());
  _retval.Assign(attrib.data(), attrib.length());

  return NS_OK;
}

/* boolean cmpAttrib (in string name, in string value); */
NS_IMETHODIMP Judo_ConstElement_Wrapper::CmpAttrib(const nsACString &name,
						   const nsACString &value,
						   PRBool *_retval)
{
  *_retval = element_->cmpAttrib(PromiseFlatCString(name).get(),
				 PromiseFlatCString(value).get());
  return NS_OK;
}

/* string getCDATA (); */
NS_IMETHODIMP Judo_ConstElement_Wrapper::GetCDATA(nsACString &_retval)
{
  const std::string cdata = element_->getCDATA();
  _retval.Assign(cdata.data(), cdata.length());

  return NS_OK;
}

/* judoIElement getElement (in string name); */
NS_IMETHODIMP
Judo_ConstElement_Wrapper::FindElement(const nsACString &name,
				       judoIConstElement **_retval)
{
  const judo::Element * const child_element =
    element_->findElement(PromiseFlatCString(name).get());

  if (child_element)
  {
    *_retval = new Judo_ConstElement_Wrapper(child_element);
    NS_IF_ADDREF(*_retval);
  }
  else
  {
    *_retval = NULL;
  }

  return NS_OK;
}

/* void findElements (in AUTF8String name, [array, size_is (elem_len)] out judoIConstElement elem, out unsigned long elem_len); */
NS_IMETHODIMP
Judo_ConstElement_Wrapper::FindElements(const nsACString &name,
					judoIConstElement ***elem,
					PRUint32 *elem_len)
{
  const std::string name_str = PromiseFlatCString(name).get();
  std::vector<judoIConstElement *> elements;

  for (judo::Element::const_iterator iter = element_->begin();
       iter != element_->end();
       ++iter)
  {
    if (((*iter)->getType() == judo::Node::ntElement) &&
	((*iter)->getName() == name_str))
    {
      judoIConstElement * const child_element =
	new Judo_ConstElement_Wrapper(static_cast<const judo::Element *>(*iter));

      NS_IF_ADDREF(child_element);
      elements.push_back(child_element);
    }
  }

  *elem_len = elements.size();
  *elem = (judoIConstElement **)
    nsMemory::Clone(&elements[0], sizeof (judoIConstElement *) * *elem_len);

  return NS_OK;
}

/* void getElements ([array, size_is (elem_len)] out judoIConstElement elem, out unsigned long elem_len); */
NS_IMETHODIMP Judo_ConstElement_Wrapper::GetElements(judoIConstElement ***elem,
						     PRUint32 *elem_len)
{
  std::vector<judoIConstElement *> elements;

  for (judo::Element::const_iterator iter = element_->begin();
       iter != element_->end();
       ++iter)
  {
    if ((*iter)->getType() == judo::Node::ntElement)
    {
      judoIConstElement * const child_element =
	new Judo_ConstElement_Wrapper(static_cast<const judo::Element *>(*iter));

      NS_IF_ADDREF(child_element);
      elements.push_back(child_element);
    }
  }

  *elem_len = elements.size();
  *elem = (judoIConstElement **)
    nsMemory::Clone(&elements[0], sizeof (judoIConstElement *) * *elem_len);

  return NS_OK;
}

/* boolean empty (); */
NS_IMETHODIMP Judo_ConstElement_Wrapper::Empty(PRBool *_retval)
{
  *_retval = element_->empty();
  return NS_OK;
}

/* long size (); */
NS_IMETHODIMP Judo_ConstElement_Wrapper::Size(PRInt32 *_retval)
{
  *_retval = element_->size();
  return NS_OK;
}


void Judo_ConstElement_Wrapper::detach()
{
  if (!managed_object_)
  {
#ifdef JABXPCOM_DEBUG
    printf("detaching Judo_ConstElement_Wrapper()\n");
#endif

    element_ = new judo::Element(*element_);
    managed_object_ = true;

    Judo_Node_Wrapper::detach(element_);
  }
}


NS_IMPL_ISUPPORTS_INHERITED1(Judo_Element_Wrapper,
			     Judo_ConstElement_Wrapper,
			     judoIElement)

Judo_Element_Wrapper::Judo_Element_Wrapper(judo::Element *element)
  : Judo_ConstElement_Wrapper(element),
    element_(element), managed_object_(false)
{
  /* member initializers and constructor code */
#ifdef JABXPCOM_DEBUG
  printf("constructing Judo_Element_Wrapper(%d)\n", managed_object_);
#endif
}

Judo_Element_Wrapper::~Judo_Element_Wrapper()
{
  /* destructor code */
#ifdef JABXPCOM_DEBUG
  printf("deleting Judo_Element_Wrapper(%d)\n", managed_object_);
#endif

  if (managed_object_)
  {
    delete element_;
  }
}

/* judoIElement addElement (in string name); */
NS_IMETHODIMP Judo_Element_Wrapper::AddElement(const nsACString &name,
					       judoIElement **_retval)
{
  judo::Element *child_element =
    element_->addElement(PromiseFlatCString(name).get());

  if (child_element)
  {
    *_retval = new Judo_Element_Wrapper(child_element);
    NS_IF_ADDREF(*_retval);
  }
  else
  {
    *_retval = NULL;
  }

  return NS_OK;
}

/* judoICDATA addCDATA (in string pCDATA); */
NS_IMETHODIMP Judo_Element_Wrapper::AddCDATA(const nsACString &pCDATA,
					     judoICDATA **_retval)
{
  judo::CDATA *cdata = element_->addCDATA(PromiseFlatCString(pCDATA).get(),
					  pCDATA.Length());

  // not supported at the moment
  *_retval = NULL;

  return NS_OK;
}

/* void putAttrib (in string name, in string value); */
NS_IMETHODIMP Judo_Element_Wrapper::PutAttrib(const nsACString &name,
					      const nsACString &value)
{
  element_->putAttrib(PromiseFlatCString(name).get(),
		      PromiseFlatCString(value).get());

  return NS_OK;
}

/* void delAttrib (in string name); */
NS_IMETHODIMP Judo_Element_Wrapper::DelAttrib(const nsACString &name)
{
  element_->delAttrib(PromiseFlatCString(name).get());

  return NS_OK;
}


void Judo_Element_Wrapper::detach()
{
  if (!managed_object_)
  {
#ifdef JABXPCOM_DEBUG
    printf("constructing Judo_Element_Wrapper(%d)\n", managed_object_);
#endif

    element_ = new judo::Element(*element_);
    managed_object_ = true;

    Judo_ConstElement_Wrapper::detach(element_);
  }
}