/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */
#include "nsTableCell.h"
#include "nsTableCellFrame.h"
#include "nsHTMLParts.h"
#include "nsIStyleContext.h"
#include "nsStyleConsts.h"
#include "nsIPresContext.h"
#include "nsIDocument.h"
#include "nsIURL.h"
#include "nsHTMLIIDs.h"
#include "nsHTMLAtoms.h"
#include "nsIPtr.h"

// hack, remove when hack in nsTableCol constructor is removed
static PRInt32 HACKcounter=0;
static nsIAtom *HACKattribute=nsnull;
#include "prprf.h"  // remove when nsTableCol constructor hack is removed
// end hack code


NS_DEF_PTR(nsIStyleContext);

static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);

#ifdef NS_DEBUG
static PRBool gsDebug = PR_FALSE;
static PRBool gsNoisyRefs = PR_FALSE;
#else
static const PRBool gsDebug = PR_FALSE;
static const PRBool gsNoisyRefs = PR_FALSE;
#endif

// nsTableContent checks aTag
nsTableCell::nsTableCell(nsIAtom* aTag)
  : nsTableContent(aTag),
  mRow(0),
  mRowSpan(1),
  mColSpan(1),
  mColIndex(0)
{
  mImplicit = PR_FALSE;
  Init();
}

nsTableCell::nsTableCell(PRBool aImplicit)
  : nsTableContent(NS_NewAtom(nsTablePart::kDataCellTagString)),
  mRow(0),
  mRowSpan(1),
  mColSpan(1),
  mColIndex(0)
{
  mImplicit = aImplicit;
  Init();
}

// nsTableContent checks aTag
nsTableCell::nsTableCell (nsIAtom* aTag, int aRowSpan, int aColSpan)
  : nsTableContent(aTag),
  mRow(0),
  mRowSpan(aRowSpan),
  mColSpan(aColSpan),
  mColIndex(0)
{
  NS_ASSERTION(0<aRowSpan, "bad row span");
  NS_ASSERTION(0<aColSpan, "bad col span");
  mImplicit = PR_FALSE;
  Init();
}

void nsTableCell::Init()
{
  /* begin hack */
  // temporary hack to get around style sheet optimization that folds all
  // col style context into one, unless there is a unique HTML attribute set
  char out[40];
  PR_snprintf(out, 40, "%d", HACKcounter);
  const nsAutoString value(out);
  if (nsnull==HACKattribute)
    HACKattribute = NS_NewAtom("Steve's unbelievable hack attribute");
  SetAttribute(HACKattribute, value);
  HACKcounter++;
  /* end hack */
}

nsTableCell::~nsTableCell()
{
#if 0
  // XXX Circular reference between table row and table cell
  NS_IF_RELEASE(mRow);
#endif
}

// for debugging only
nsrefcnt nsTableCell::AddRef(void)
{
  if (gsNoisyRefs) printf("Add Ref: %x, nsTableCell cnt = %d \n",this, mRefCnt+1);
  return ++mRefCnt;
}

// for debugging only
nsrefcnt nsTableCell::Release(void)
{
  if (gsNoisyRefs==PR_TRUE) printf("Release: %x, nsTableCell cnt = %d \n",this, mRefCnt-1);
  if (--mRefCnt == 0) {
    if (gsNoisyRefs==PR_TRUE) printf("Delete: %x, nsTableCell \n",this);
    delete this;
    return 0;
  }
  return mRefCnt;
}

int nsTableCell::GetType()
{
  return nsITableContent::kTableCellType;
}

int nsTableCell::GetRowSpan ()
{
  NS_ASSERTION(0<mRowSpan, "bad row span");
  return mRowSpan;
}

int nsTableCell::GetColSpan ()
{
  NS_ASSERTION(0<mColSpan, "bad col span");
  return mColSpan;
}

nsTableRow * nsTableCell::GetRow ()
{
  NS_IF_ADDREF(mRow);
  return mRow;
}

void nsTableCell::SetRow (nsTableRow * aRow)
{
#if 0
  // XXX Circular reference between table row and table cell
  NS_IF_RELEASE(mRow);
  mRow = aRow;
  NS_IF_ADDREF(aRow);
#else
  mRow = aRow;
#endif
}

int nsTableCell::GetColIndex ()
{
  NS_ASSERTION(0<=mColIndex, "bad column index");
  return mColIndex;
}

void nsTableCell::SetColIndex (int aColIndex)
{
  NS_ASSERTION(0<=aColIndex, "illegal negative column index.");
  mColIndex = aColIndex;
}

nsresult
nsTableCell::CreateFrame(nsIPresContext* aPresContext,
                         nsIFrame* aParentFrame,
                         nsIStyleContext* aStyleContext,
                         nsIFrame*& aResult)
{
  NS_PRECONDITION(nsnull!=aPresContext, "bad arg");

  nsIFrame* frame;
  nsresult rv = nsTableCellFrame::NewFrame(&frame, this, aParentFrame);
  if (NS_OK != rv) {
    return rv;
  }
  ((nsTableCellFrame*)frame)->Init(mRowSpan, mColSpan, mColIndex);
  frame->SetStyleContext(aPresContext, aStyleContext);
  aResult = frame;
  return rv;
}

void nsTableCell::SetAttribute(nsIAtom* aAttribute, const nsString& aValue)
{
  NS_PRECONDITION(nsnull!=aAttribute, "bad attribute arg");
  nsHTMLValue val;
  if ((aAttribute == nsHTMLAtoms::align) &&
      ParseDivAlignParam(aValue, val)) {
    nsHTMLTagContent::SetAttribute(aAttribute, val);
    return;
  }
  if ((aAttribute == nsHTMLAtoms::valign) &&
      ParseAlignParam(aValue, val)) {
    nsHTMLTagContent::SetAttribute(aAttribute, val);
    return;
  }
  if (aAttribute == nsHTMLAtoms::background) {
    nsAutoString href(aValue);
    href.StripWhitespace();
    nsHTMLTagContent::SetAttribute(aAttribute, href);
    return;
  }
  if (aAttribute == nsHTMLAtoms::bgcolor) {
    ParseColor(aValue, val);
    nsHTMLTagContent::SetAttribute(aAttribute, val);
    return;
  }
  if (aAttribute == nsHTMLAtoms::rowspan) {
    ParseValue(aValue, 1, 10000, val, eHTMLUnit_Integer);
    SetRowSpan(val.GetIntValue());
    nsHTMLTagContent::SetAttribute(aAttribute, val);
    return;
  }
  if (aAttribute == nsHTMLAtoms::colspan) {
    ParseValue(aValue, 1, 1000, val, eHTMLUnit_Integer);
    SetColSpan(val.GetIntValue());
    nsHTMLTagContent::SetAttribute(aAttribute, val);
    return;
  }
  if (aAttribute == nsHTMLAtoms::width) {
    ParseValueOrPercent(aValue, val, eHTMLUnit_Pixel);
    nsHTMLTagContent::SetAttribute(aAttribute, val);
    return;
  }
  if (aAttribute == nsHTMLAtoms::height) {
    ParseValueOrPercent(aValue, val, eHTMLUnit_Pixel);
    nsHTMLTagContent::SetAttribute(aAttribute, val);
    return;
  }
  if (aAttribute == nsHTMLAtoms::nowrap) {
    val.SetEmptyValue();
    nsHTMLTagContent::SetAttribute(aAttribute, val);
    return;
  }
  // Use default attribute catching code
  nsTableContent::SetAttribute(aAttribute, aValue);
}



void nsTableCell::MapAttributesInto(nsIStyleContext* aContext,
                                    nsIPresContext* aPresContext)
{
  NS_PRECONDITION(nsnull!=aContext, "bad style context arg");
  NS_PRECONDITION(nsnull!=aPresContext, "bad presentation context arg");

  nsHTMLValue value;
  nsHTMLValue widthValue;
  nsStyleText* textStyle = nsnull;

  // align: enum
  GetAttribute(nsHTMLAtoms::align, value);
  if (value.GetUnit() == eHTMLUnit_Enumerated) 
  {
    textStyle = (nsStyleText*)aContext->GetMutableStyleData(eStyleStruct_Text);
    textStyle->mTextAlign = value.GetIntValue();
  }
  // otherwise check the row for align and inherit it
  else {
    if (nsnull!=mRow)
    {
      // TODO: optimize by putting a flag on the row to say whether align attr is set
      nsHTMLValue parentAlignValue;
      mRow->GetAttribute(nsHTMLAtoms::align, parentAlignValue);
      if (parentAlignValue.GetUnit() == eHTMLUnit_Enumerated)
      {
        PRUint8 rowAlign = parentAlignValue.GetIntValue();
        if (nsnull==textStyle)
          textStyle = (nsStyleText*)aContext->GetMutableStyleData(eStyleStruct_Text);
        textStyle->mTextAlign = rowAlign;
      }
      else
      { // we need to check the row group as well
        nsTableRowGroup *rowGroup = mRow->GetRowGroup();
        if (nsnull!=rowGroup)
        {
          rowGroup->GetAttribute(nsHTMLAtoms::align, parentAlignValue);
          if (parentAlignValue.GetUnit() == eHTMLUnit_Enumerated)
          {
            PRUint8 rowGroupAlign = parentAlignValue.GetIntValue();
            if (nsnull==textStyle)
              textStyle = (nsStyleText*)aContext->GetMutableStyleData(eStyleStruct_Text);
            textStyle->mTextAlign = rowGroupAlign;
          }
          NS_RELEASE(rowGroup);
        }
      }
    }
  }
  
  // valign: enum
  GetAttribute(nsHTMLAtoms::valign, value);
  if (value.GetUnit() == eHTMLUnit_Enumerated) 
  {
    if (nsnull==textStyle)
      textStyle = (nsStyleText*)aContext->GetMutableStyleData(eStyleStruct_Text);
    textStyle->mVerticalAlign.SetIntValue(value.GetIntValue(), eStyleUnit_Enumerated);
  }
  // otherwise check the row for valign and inherit it
  else {
    if (nsnull!=mRow)
    {
      // TODO: optimize by putting a flag on the row to say whether valign attr is set
      nsHTMLValue parentAlignValue;
      mRow->GetAttribute(nsHTMLAtoms::valign, parentAlignValue);
      if (parentAlignValue.GetUnit() == eHTMLUnit_Enumerated)
      {
        PRUint8 rowVAlign = parentAlignValue.GetIntValue();
        if (nsnull==textStyle)
          textStyle = (nsStyleText*)aContext->GetMutableStyleData(eStyleStruct_Text);
        textStyle->mVerticalAlign.SetIntValue(rowVAlign, eStyleUnit_Enumerated);
      }
      else
      { // we need to check the row group as well
        nsTableRowGroup *rowGroup = mRow->GetRowGroup();
        if (nsnull!=rowGroup)
        {
          rowGroup->GetAttribute(nsHTMLAtoms::valign, parentAlignValue);
          if (parentAlignValue.GetUnit() == eHTMLUnit_Enumerated)
          {
            PRUint8 rowGroupVAlign = parentAlignValue.GetIntValue();
            if (nsnull==textStyle)
              textStyle = (nsStyleText*)aContext->GetMutableStyleData(eStyleStruct_Text);
            textStyle->mVerticalAlign.SetIntValue(rowGroupVAlign, eStyleUnit_Enumerated);
          }
          NS_RELEASE(rowGroup);
        }
      }
    }
  }

  MapBackgroundAttributesInto(aContext, aPresContext);

  // width: pixel
  float p2t = aPresContext->GetPixelsToTwips();
  nsStylePosition* pos = (nsStylePosition*)
    aContext->GetMutableStyleData(eStyleStruct_Position);
  GetAttribute(nsHTMLAtoms::width, widthValue);
  if (widthValue.GetUnit() == eHTMLUnit_Pixel) {
    nscoord twips = NSIntPixelsToTwips(widthValue.GetPixelValue(), p2t);
    pos->mWidth.SetCoordValue(twips);
  }
  else if (widthValue.GetUnit() == eHTMLUnit_Percent) {
    pos->mWidth.SetPercentValue(widthValue.GetPercentValue());
  }

  // height: pixel
  GetAttribute(nsHTMLAtoms::height, value);
  if (value.GetUnit() == eHTMLUnit_Pixel) {
    nscoord twips = NSIntPixelsToTwips(value.GetPixelValue(), p2t);
    pos->mHeight.SetCoordValue(twips);
  }

  // nowrap
  // nowrap depends on the width attribute, so be sure to handle it after width is mapped!
  GetAttribute(nsHTMLAtoms::nowrap, value);
  if (value.GetUnit() == eHTMLUnit_Empty)
  {
    if (widthValue.GetUnit() != eHTMLUnit_Pixel)
    {
      if (nsnull==textStyle)
        textStyle = (nsStyleText*)aContext->GetMutableStyleData(eStyleStruct_Text);
      textStyle->mWhiteSpace = NS_STYLE_WHITESPACE_NOWRAP;
    }
  }
}

void
nsTableCell::MapBackgroundAttributesInto(nsIStyleContext* aContext,
                                         nsIPresContext* aPresContext)
{
  nsHTMLValue value;
  nsStyleColor* color=nsnull;

  // background
  if (eContentAttr_HasValue == GetAttribute(nsHTMLAtoms::background, value)) {
    if (eHTMLUnit_String == value.GetUnit()) {
      color = (nsStyleColor*)aContext->GetMutableStyleData(eStyleStruct_Color);
      SetBackgroundFromAttribute(color, &value);
    }
  }
  // otherwise check the row for background and inherit it
  else 
  {
    if (nsnull!=mRow)
    {
      // TODO: optimize by putting a flag on the row to say whether background attr is set
      mRow->GetAttribute(nsHTMLAtoms::background, value);
      if (value.GetUnit() == eHTMLUnit_String)
      {
        nsString rowBackground;
        value.GetStringValue(rowBackground);
        if (nsnull==color)
          color = (nsStyleColor*)aContext->GetMutableStyleData(eStyleStruct_Color);
        SetBackgroundFromAttribute(color, &value);
      }
      else
      { // we need to check the row group as well
        nsTableRowGroup *rowGroup = mRow->GetRowGroup();
        if (nsnull!=rowGroup)
        {
          rowGroup->GetAttribute(nsHTMLAtoms::background, value);
          if (value.GetUnit() == eHTMLUnit_String)
          {
            nsString rowBackground;
            value.GetStringValue(rowBackground);
            if (nsnull==color)
              color = (nsStyleColor*)aContext->GetMutableStyleData(eStyleStruct_Color);
            SetBackgroundFromAttribute(color, &value);
          }
          NS_RELEASE(rowGroup);
        }
      }
    }
  }

  // bgcolor
  if (eContentAttr_HasValue == GetAttribute(nsHTMLAtoms::bgcolor, value)) {
    if (eHTMLUnit_Color == value.GetUnit()) {
      if (nsnull==color)
        color = (nsStyleColor*)aContext->GetMutableStyleData(eStyleStruct_Color);
      color->mBackgroundColor = value.GetColorValue();
      color->mBackgroundFlags &= ~NS_STYLE_BG_COLOR_TRANSPARENT;
    }
    else if (eHTMLUnit_String == value.GetUnit()) {
      nsAutoString buffer;
      value.GetStringValue(buffer);
      char cbuf[40];
      buffer.ToCString(cbuf, sizeof(cbuf));

      if (nsnull==color)
        color = (nsStyleColor*)aContext->GetMutableStyleData(eStyleStruct_Color);
      NS_ColorNameToRGB(cbuf, &(color->mBackgroundColor));
      color->mBackgroundFlags &= ~NS_STYLE_BG_COLOR_TRANSPARENT;
    }
  }
  // otherwise check the row for background and inherit it
  else 
  {
    if (nsnull!=mRow)
    {
      // TODO: optimize by putting a flag on the row to say whether bgcolor attr is set
      if (eContentAttr_HasValue == mRow->GetAttribute(nsHTMLAtoms::bgcolor, value))
      {
        if (eHTMLUnit_Color == value.GetUnit()) {
          if (nsnull==color)
            color = (nsStyleColor*)aContext->GetMutableStyleData(eStyleStruct_Color);
          color->mBackgroundColor = value.GetColorValue();
          color->mBackgroundFlags &= ~NS_STYLE_BG_COLOR_TRANSPARENT;
        }
        else if (eHTMLUnit_String == value.GetUnit()) {
          nsAutoString buffer;
          value.GetStringValue(buffer);
          char cbuf[40];
          buffer.ToCString(cbuf, sizeof(cbuf));
          if (nsnull==color)
            color = (nsStyleColor*)aContext->GetMutableStyleData(eStyleStruct_Color);
          NS_ColorNameToRGB(cbuf, &(color->mBackgroundColor));
          color->mBackgroundFlags &= ~NS_STYLE_BG_COLOR_TRANSPARENT;
        }
      }
      else
      { // we need to check the row group as well
        nsTableRowGroup *rowGroup = mRow->GetRowGroup();
        if (nsnull!=rowGroup)
        {
          if (eContentAttr_HasValue == rowGroup->GetAttribute(nsHTMLAtoms::bgcolor, value)) {
            if (eHTMLUnit_Color == value.GetUnit()) {
              if (nsnull==color)
                color = (nsStyleColor*)aContext->GetMutableStyleData(eStyleStruct_Color);
              color->mBackgroundColor = value.GetColorValue();
              color->mBackgroundFlags &= ~NS_STYLE_BG_COLOR_TRANSPARENT;
            }
            else if (eHTMLUnit_String == value.GetUnit()) {
              nsAutoString buffer;
              value.GetStringValue(buffer);
              char cbuf[40];
              buffer.ToCString(cbuf, sizeof(cbuf));

              if (nsnull==color)
                color = (nsStyleColor*)aContext->GetMutableStyleData(eStyleStruct_Color);
              NS_ColorNameToRGB(cbuf, &(color->mBackgroundColor));
              color->mBackgroundFlags &= ~NS_STYLE_BG_COLOR_TRANSPARENT;
            }
          }
          NS_RELEASE(rowGroup);
        }
      }
    }
  }
}

void nsTableCell::SetBackgroundFromAttribute(nsStyleColor *aColor, nsHTMLValue *aValue)
{
  NS_ASSERTION(nsnull!=aColor && nsnull!=aValue, "bad args");

  // Resolve url to an absolute url
  nsIURL* docURL = nsnull;
  nsIDocument* doc = mDocument;
  if (nsnull != doc) {
    docURL = doc->GetDocumentURL();
  }

  nsAutoString absURLSpec;
  nsAutoString spec;
  aValue->GetStringValue(spec);
  nsresult rv = NS_MakeAbsoluteURL(docURL, "", spec, absURLSpec);
  if (nsnull != docURL) {
    NS_RELEASE(docURL);
  }
  aColor->mBackgroundImage = absURLSpec;
  aColor->mBackgroundFlags &= ~NS_STYLE_BG_IMAGE_NONE;
  aColor->mBackgroundRepeat = NS_STYLE_BG_REPEAT_XY;
}

nsContentAttr
nsTableCell::AttributeToString(nsIAtom* aAttribute,
                               nsHTMLValue& aValue,
                               nsString& aResult) const
{
  nsContentAttr ca = eContentAttr_NotThere;
  if (aAttribute == nsHTMLAtoms::valign) {
    AlignParamToString(aValue, aResult);
    ca = eContentAttr_HasValue;
  }
  else {
    ca = nsTableContent::AttributeToString(aAttribute, aValue, aResult);
  }
  return ca;
}

void nsTableCell::SetRowSpan(int aRowSpan)
{
  NS_ASSERTION(0<aRowSpan, "bad row span");
  int oldSpan = mRowSpan;
  mRowSpan = aRowSpan;
}

void nsTableCell::SetColSpan (int aColSpan)
{
  NS_ASSERTION(0<aColSpan, "bad col span");
  int oldSpan = mColSpan;
  mColSpan = aColSpan;
}

nsresult
NS_NewTableCellPart(nsIHTMLContent** aInstancePtrResult,
                    nsIAtom* aTag)
{
  NS_PRECONDITION(nsnull != aInstancePtrResult, "nsnull ptr");
  if (nsnull == aInstancePtrResult) {
    return NS_ERROR_NULL_POINTER;
  }
  nsIHTMLContent* body = new nsTableCell(aTag);
  if (nsnull == body) {
    return NS_ERROR_OUT_OF_MEMORY;
  }
  return body->QueryInterface(kIHTMLContentIID, (void **) aInstancePtrResult);
}