//=========================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//=========================================================================

#include "vtkModelEdgeUse.h"

#include "vtkInformation.h"
#include "vtkInformationIntegerKey.h"
#include "vtkModel.h"
#include "vtkModelEdge.h"
#include "vtkModelItemIterator.h"
#include "vtkModelLoopUse.h"
#include "vtkModelVertex.h"
#include "vtkModelVertexUse.h"
#include "vtkObjectFactory.h"

vtkInformationKeyMacro(vtkModelEdgeUse, DIRECTION, Integer);

vtkModelEdgeUse* vtkModelEdgeUse::New()
{
  vtkObject* ret = vtkObjectFactory::CreateInstance("vtkModelEdgeUse");
  if (ret)
  {
    return static_cast<vtkModelEdgeUse*>(ret);
  }
  return new vtkModelEdgeUse;
}

vtkModelEdgeUse::vtkModelEdgeUse()
{
}

vtkModelEdgeUse::~vtkModelEdgeUse()
{
}

bool vtkModelEdgeUse::Destroy()
{
  if (this->GetModelLoopUse())
  {
    vtkErrorMacro("Trying to remove a ModelEdgeUse that is still connected to a ModelLoopUse.");
    return false;
  }
  // if I'm connected to a vertex use that isn't connected to any other edge uses
  // then I need to destroy that vertex use too.

  vtkModelVertexUse* vertexUse0 = this->GetModelVertexUse(0);
  if (vertexUse0)
  {
    if (vertexUse0->GetNumberOfModelEdgeUses() == 1)
    {
      vertexUse0->Destroy();
    }
  }
  vtkModelVertexUse* vertexUse1 = this->GetModelVertexUse(1);
  if (vertexUse1)
  {
    if (vertexUse1->GetNumberOfModelEdgeUses() == 1)
    {
      vertexUse1->Destroy();
    }
    else if (vertexUse0 == vertexUse1)
    {
      // also if this edge use is a loop then I'm connected to the same
      // vertex use twice and must also remove both uses
      vertexUse0->Destroy();
    }
  }

  this->RemoveAllAssociations(vtkModelVertexUseType);
  // my pair will have to remove me separately
  this->RemoveReverseAssociationToType(this->GetPairedModelEdgeUse(), this->GetType());

  return true;
}

int vtkModelEdgeUse::GetType()
{
  return vtkModelEdgeUseType;
}

vtkModelEdge* vtkModelEdgeUse::GetModelEdge()
{
  vtkModelItemIterator* iter = this->NewIterator(vtkModelEdgeType);
  iter->Begin();
  vtkModelEdge* edge = vtkModelEdge::SafeDownCast(iter->GetCurrentItem());
  iter->Delete();
  return edge;
}

vtkModelEdgeUse* vtkModelEdgeUse::GetPairedModelEdgeUse()
{
  vtkModelItemIterator* iter = this->NewIterator(vtkModelEdgeUseType);
  iter->Begin();
  vtkModelEdgeUse* edgeUse = vtkModelEdgeUse::SafeDownCast(iter->GetCurrentItem());
  iter->Delete();
  return edgeUse;
}

vtkModelLoopUse* vtkModelEdgeUse::GetModelLoopUse()
{
  vtkModelItemIterator* iter = this->NewIterator(vtkModelLoopUseType);
  iter->Begin();
  vtkModelLoopUse* loopUse = vtkModelLoopUse::SafeDownCast(iter->GetCurrentItem());
  iter->Delete();
  return loopUse;
}

void vtkModelEdgeUse::SetModelVertexUses(
  vtkModelVertexUse* vertexUse0, vtkModelVertexUse* vertexUse1)
{
  this->RemoveAllAssociations(vtkModelVertexUseType);
  if (vertexUse0)
  {
    this->AddAssociation(vertexUse0);
    if (vertexUse1)
    {
      this->AddAssociation(vertexUse1);
    }
  }
  else if (vertexUse1)
  {
    vtkWarningMacro("Trying to set vertexUse1 without setting vertexUse0");
  }
}

vtkModelVertexUse* vtkModelEdgeUse::GetModelVertexUse(int i)
{
  vtkModelItemIterator* iter = this->NewIterator(vtkModelVertexUseType);
  iter->Begin();
  if (iter->IsAtEnd())
  {
    iter->Delete();
    return 0;
  }
  if (i == 0)
  {
    vtkModelVertexUse* vertexUse = vtkModelVertexUse::SafeDownCast(iter->GetCurrentItem());
    iter->Delete();
    return vertexUse;
  }
  iter->Next();
  if (iter->IsAtEnd())
  {
    iter->Delete();
    return 0;
  }
  vtkModelVertexUse* vertexUse = vtkModelVertexUse::SafeDownCast(iter->GetCurrentItem());
  iter->Delete();
  return vertexUse;
}

int vtkModelEdgeUse::GetNumberOfModelVertexUses()
{
  return this->GetNumberOfAssociations(vtkModelVertexUseType);
}

int vtkModelEdgeUse::GetDirection()
{
  return this->GetProperties()->Get(DIRECTION());
}

void vtkModelEdgeUse::Initialize(
  vtkModelVertex* vertex0, vtkModelVertex* vertex1, vtkModelEdgeUse* pairedEdgeUse, int direction)
{
  if (vertex0)
  {
    vtkModelVertexUse* VertexUse = vtkModelVertexUse::New();
    VertexUse->Initialize(vertex0);
    this->AddAssociation(VertexUse);
    VertexUse->Delete();
    if (vertex1)
    {
      VertexUse = vtkModelVertexUse::New();
      VertexUse->Initialize(vertex1);
      this->AddAssociation(VertexUse);
      VertexUse->Delete();
    }
  }
  if (direction != 0)
  {
    direction = 1;
  }
  this->SetDirection(direction);
  // only add reverse association as my pair also will have to call
  // initialize and do the same thing
  this->AddReverseAssociationToType(pairedEdgeUse, vtkModelEdgeUseType);
}

void vtkModelEdgeUse::SetDirection(int direction)
{
  this->GetProperties()->Set(DIRECTION(), direction);
}

void vtkModelEdgeUse::Serialize(vtkSerializer* ser)
{
  this->Superclass::Serialize(ser);
}

void vtkModelEdgeUse::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os, indent);
}
