// Copyright (C) 2014-2015  EDF-R&D
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// 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
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

%ExportedHeaderCode
#include <HYDROData_CalculationCase.h>
#include <HYDROData_PriorityQueue.h>
%End

enum HYDROData_PriorityType
{
  LESS,
  GREATER,
};

class HYDROData_CalculationCase : public HYDROData_Entity
{

%TypeHeaderCode
#include <HYDROData_CalculationCase.h>
%End

%ConvertToSubClassCode
    switch ( sipCpp->GetKind() )
    {
      case KIND_CALCULATION:
        sipClass = sipClass_HYDROData_CalculationCase;
        break;

      default:
        // We don't recognise the type.
        sipClass = NULL;
    }
%End

public:

  enum PointClassification
  {
    POINT_OUT,  ///< point is out of zone face
    POINT_IN,   ///< point is inside of zone face
    POINT_ON    ///< point is on the edge of zone face
  };

  enum AssignmentMode
  {
    MANUAL = 0,
    AUTOMATIC,
  };

public:      
  /**
   * Add new one reference geometry object for calculation case.
   */
  bool AddGeometryObject( HYDROData_Object theObject ) [bool ( const Handle_HYDROData_Object& )];
  %MethodCode
    Handle(HYDROData_Object) aRef =
      Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
    if ( !aRef.IsNull() )
    {
      Py_BEGIN_ALLOW_THREADS
      sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddGeometryObject( aRef ):
                               sipCpp->AddGeometryObject( aRef );
      Py_END_ALLOW_THREADS
    }
  %End

  /**
   * Returns all reference geometry objects of calculation case.
   */
  HYDROData_SequenceOfObjects GetGeometryObjects() const;

  /**
   * Removes reference geometry object from calculation case.
   */
  void RemoveGeometryObject( HYDROData_Object theObject ) [void ( const Handle_HYDROData_Object& )];
  %MethodCode
    Handle(HYDROData_Object) aRef =
      Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
    if ( !aRef.IsNull() )
    {
      Py_BEGIN_ALLOW_THREADS
      if ( sipSelfWasArg ) {
        sipCpp->HYDROData_CalculationCase::RemoveGeometryObject( aRef );
      } else {
        sipCpp->RemoveGeometryObject( aRef );
      }
      Py_END_ALLOW_THREADS
    }
  %End

  /**
   * Removes all reference geometry objects from calculation case.
   */
  void RemoveGeometryObjects();


  /**
   * Add new one reference geometry group for calculation case.
   */
  bool AddGeometryGroup( HYDROData_ShapesGroup theGroup ) [bool ( const Handle_HYDROData_ShapesGroup& )];
  %MethodCode
    Handle(HYDROData_ShapesGroup) aRef =
      Handle(HYDROData_ShapesGroup)::DownCast( createHandle( a0 ) );
    if ( !aRef.IsNull() )
    {
      Py_BEGIN_ALLOW_THREADS
      sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddGeometryGroup( aRef ):
                               sipCpp->AddGeometryGroup( aRef );
      Py_END_ALLOW_THREADS
    }
  %End

  /**
   * Returns all reference geometry groups of calculation case.
   */
  HYDROData_SequenceOfObjects GetGeometryGroups() const;

  /**
   * Removes reference geometry group from calculation case.
   */
  void RemoveGeometryGroup( HYDROData_ShapesGroup theGroup ) [void ( const Handle_HYDROData_ShapesGroup& )];
  %MethodCode
    Handle(HYDROData_ShapesGroup) aRef =
      Handle(HYDROData_ShapesGroup)::DownCast( createHandle( a0 ) );
    if ( !aRef.IsNull() )
    {
      Py_BEGIN_ALLOW_THREADS
      if ( sipSelfWasArg ) {
        sipCpp->HYDROData_CalculationCase::RemoveGeometryGroup( aRef );
      } else {
        sipCpp->RemoveGeometryGroup( aRef );
      }
      Py_END_ALLOW_THREADS
    }
  %End

  /**
   * Removes all reference geometry groups from calculation case.
   */
  void RemoveGeometryGroups();


  /**
   * Sets reference boundary polyline object for calculation case.
   */
  void SetBoundaryPolyline( HYDROData_PolylineXY thePolyline ) [void ( const Handle_HYDROData_PolylineXY& )];
  %MethodCode
    Handle(HYDROData_PolylineXY) aRef =
      Handle(HYDROData_PolylineXY)::DownCast( createHandle( a0 ) );
    if ( !aRef.IsNull() )
    {
      Py_BEGIN_ALLOW_THREADS
      if ( sipSelfWasArg ) {
        sipCpp->HYDROData_CalculationCase::SetBoundaryPolyline( aRef );
      } else {
        sipCpp->SetBoundaryPolyline( aRef );
      }
      Py_END_ALLOW_THREADS
    }
  %End

  /**
   * Returns reference boundary polyline object of calculation case.
   */
  HYDROData_PolylineXY GetBoundaryPolyline() const [Handle_HYDROData_PolylineXY ()];
  %MethodCode
    Handle(HYDROData_PolylineXY) aRef;
    
    Py_BEGIN_ALLOW_THREADS
    aRef = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetBoundaryPolyline() : 
                           sipCpp->GetBoundaryPolyline();
    Py_END_ALLOW_THREADS
    
    sipRes = (HYDROData_PolylineXY*)createPointer( aRef );
  %End

  /**
   * Remove reference boundary polyline object from calculation case.
   */
  void RemoveBoundaryPolyline();


  /**
   * Add new one child region for calculation case.
   * The new region is added into the list of reference regions.
   * The label of theZone is changed during this operation
   * because of new region becomes the new parent for this zone.
   */
  HYDROData_Region AddNewRegion( HYDROData_Zone theZone ) [Handle_HYDROData_Region ( const Handle_HYDROData_Zone& )];
  %MethodCode
    Handle(HYDROData_Zone) aRef =
      Handle(HYDROData_Zone)::DownCast( createHandle( a0 ) );
    Handle(HYDROData_Region) aRes;
    
    if ( !aRef.IsNull() )
    {
      Py_BEGIN_ALLOW_THREADS
      aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddNewRegion( aRef ) : 
                             sipCpp->AddNewRegion( aRef );
      Py_END_ALLOW_THREADS
    }
    
    sipRes = (HYDROData_Region*)createPointer( aRes );
  %End

  /**
   * Add new one reference region for calculation case.
   * The label of theRegion is changed in case if old parent is not this calculation.
   */
  bool AddRegion( HYDROData_Region theRegion ) [bool ( const Handle_HYDROData_Region& )];
  %MethodCode
    Handle(HYDROData_Region) aRef =
      Handle(HYDROData_Region)::DownCast( createHandle( a0 ) );
    if ( !aRef.IsNull() )
    {
      Py_BEGIN_ALLOW_THREADS
      sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddRegion( aRef ):
                               sipCpp->AddRegion( aRef );
      Py_END_ALLOW_THREADS
    }
  %End

  /**
   * Returns all reference regions of calculation case.
   */
  HYDROData_SequenceOfObjects GetRegions() const;

  /**
   * Updates names of regions to correct order.
   */
  void UpdateRegionsOrder();

  /**
   * Removes reference region from calculation case.
   */
  void RemoveRegion( HYDROData_Region theRegion ) [void ( const Handle_HYDROData_Region& )];
  %MethodCode
    Handle(HYDROData_Region) aRef =
      Handle(HYDROData_Region)::DownCast( createHandle( a0 ) );
    if ( !aRef.IsNull() )
    {
      Py_BEGIN_ALLOW_THREADS
      if ( sipSelfWasArg ) {
        sipCpp->HYDROData_CalculationCase::RemoveRegion( aRef );
      } else {
        sipCpp->RemoveRegion( aRef );
      }
      Py_END_ALLOW_THREADS
    }
  %End

  /**
   * Removes all reference regions from calculation case.
   */
  void RemoveRegions();

  
  /**
   * Returns all reference geometry groups of calculation case.
   */
  HYDROData_SequenceOfObjects GetSplittedGroups() const;

  /**
   * Removes all reference geometry groups from calculation case.
   */
  void RemoveSplittedGroups();


  /**
   * Exports the calculation case data (shell and groups) to GEOM module.
   * \param theGeomEngine GEOM module engine
   * \param theStudy SALOMEDS study, is used for publishing of GEOM objects
   * \return true in case of success
   */
//TODO:  virtual bool Export( GEOM::GEOM_Gen_var theGeomEngine,
//                       SALOMEDS::Study_ptr theStudy );
	
	QString Export( int theStudyId ) const;

public:      
  // Public methods to work with Calculation services

  /**
   * Returns altitude for given point.
   * \param thePoint the point to examine
   * \return result altitude value
   */
  double GetAltitudeForPoint( const double theCoordX,
                              const double theCoordY ) const [double ( const gp_XY& )];
  %MethodCode
    gp_XY aPnt( a0, a1 );
  
    Py_BEGIN_ALLOW_THREADS
    sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt ) : 
                             sipCpp->GetAltitudeForPoint( aPnt );
    Py_END_ALLOW_THREADS
  %End

  /**
   * Returns altitude for given point on given region.
   * \param thePoint the point to examine
   * \param theRegion reference region to check
   * \return result altitude value
   */
  double GetAltitudeForPoint( const double     theCoordX,
                              const double     theCoordY,
                              HYDROData_Region theRegion ) const
  [double ( const gp_XY&, const Handle_HYDROData_Region& )];
  %MethodCode
    gp_XY aPnt( a0, a1 );
    Handle(HYDROData_Region) aRefRegion =
      Handle(HYDROData_Region)::DownCast( createHandle( a2 ) );

    Py_BEGIN_ALLOW_THREADS
    sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt, aRefRegion ) : 
                             sipCpp->GetAltitudeForPoint( aPnt, aRefRegion );
    Py_END_ALLOW_THREADS
  %End

  /**
   * Returns altitude for given point on given zone.
   * \param thePoint the point to examine
   * \param theZone reference zone to check
   * \return result altitude value
   */
  double GetAltitudeForPoint( const double theCoordX,
                              const double theCoordY,
                              HYDROData_Zone theZone ) const
  [double ( const gp_XY&, const Handle_HYDROData_Zone& )];
  %MethodCode
    gp_XY aPnt( a0, a1 );
    Handle(HYDROData_Zone) aRefZone =
      Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );

    Py_BEGIN_ALLOW_THREADS
    sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudeForPoint( aPnt, aRefZone ) : 
                             sipCpp->GetAltitudeForPoint( aPnt, aRefZone );
    Py_END_ALLOW_THREADS
  %End

  /**
   * Returns altitudes for given points on given region.
   * \param thePoints the points to examine
   * \param theZone reference region to check
   * \return result altitude value
   */
  NCollection_Sequence<double> GetAltitudesForPoints( const NCollection_Sequence<double>& theCoordsX,
                                                      const NCollection_Sequence<double>& theCoordsY,
                                                      HYDROData_Region                    theRegion ) const
  [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, const Handle_HYDROData_Region& )];
  %MethodCode

    NCollection_Sequence<gp_XY> aPnts;

    int aLen = qMin( a0->Length(), a1->Length() );
    for ( int i = 1; i <= aLen; ++i )
    {
      gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
      aPnts.Append( aPnt );
    }

    Handle(HYDROData_Region) aRefRegion =
      Handle(HYDROData_Region)::DownCast( createHandle( a2 ) );

    NCollection_Sequence<double> aRes;
    Py_BEGIN_ALLOW_THREADS
    aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefRegion ) : 
                           sipCpp->GetAltitudesForPoints( aPnts, aRefRegion );
    Py_END_ALLOW_THREADS
    
    sipRes = new NCollection_Sequence<double>( aRes );
  %End

  /**
   * Returns altitudes for given points on given zone.
   * \param thePoints the points to examine
   * \param theZone reference zone to check
   * \return result altitude value
   */
  NCollection_Sequence<double> GetAltitudesForPoints( const NCollection_Sequence<double>& theCoordsX,
                                                      const NCollection_Sequence<double>& theCoordsY,
                                                      HYDROData_Zone                      theZone ) const
  [NCollection_Sequence<double> ( const NCollection_Sequence<gp_XY>&, const Handle_HYDROData_Zone& )];
  %MethodCode

    NCollection_Sequence<gp_XY> aPnts;

    int aLen = qMin( a0->Length(), a1->Length() );
    for ( int i = 1; i <= aLen; ++i )
    {
      gp_XY aPnt( a0->Value( i ), a1->Value( i ) );
      aPnts.Append( aPnt );
    }

    Handle(HYDROData_Zone) aRefZone =
      Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );

    NCollection_Sequence<double> aRes;
    Py_BEGIN_ALLOW_THREADS
    aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetAltitudesForPoints( aPnts, aRefZone ) : 
                           sipCpp->GetAltitudesForPoints( aPnts, aRefZone );
    Py_END_ALLOW_THREADS
    
    sipRes = new NCollection_Sequence<double>( aRes );
  %End
  
  /**
   * Returns region to which the point is belongs.
   * \param thePoint the point to examine
   * \return result region
   */
  HYDROData_Region GetRegionFromPoint( const double theCoordX,
                                       const double theCoordY ) const
  [Handle_HYDROData_Region ( const gp_XY& )];
  %MethodCode
    Handle(HYDROData_Region) aRes;
    
    gp_XY aPnt( a0, a1 );
  
    Py_BEGIN_ALLOW_THREADS
    aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetRegionFromPoint( aPnt ) : 
                           sipCpp->GetRegionFromPoint( aPnt );
    Py_END_ALLOW_THREADS
    
    sipRes = (HYDROData_Region*)createPointer( aRes );
  %End

  /**
   * Returns zone to which the point is belongs.
   * \param thePoint the point to examine
   * \return result zone
   */
  HYDROData_Zone GetZoneFromPoint( const double theCoordX,
                                   const double theCoordY ) const
  [Handle_HYDROData_Zone ( const gp_XY& )];
  %MethodCode
    Handle(HYDROData_Zone) aRes;
    
    gp_XY aPnt( a0, a1 );
  
    Py_BEGIN_ALLOW_THREADS
    aRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetZoneFromPoint( aPnt ) : 
                           sipCpp->GetZoneFromPoint( aPnt );
    Py_END_ALLOW_THREADS
    
    sipRes = (HYDROData_Zone*)createPointer( aRes );
  %End

  /**
   * Returns classification of point for given zone.
   * \param thePoint the point to examine
   * \param theZone the zone to examine
   * \return result classification
   */
  PointClassification GetPointClassification( const double theCoordX,
                                              const double theCoordY,
                                              HYDROData_Zone theZone ) const 
  [PointClassification ( const gp_XY&, const Handle_HYDROData_Zone& )];    
  %MethodCode
    gp_XY aPnt( a0, a1 );

    Handle(HYDROData_Zone) aRef =
      Handle(HYDROData_Zone)::DownCast( createHandle( a2 ) );

    Py_BEGIN_ALLOW_THREADS
    sipRes = sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::GetPointClassification( aPnt, aRef ) : 
                             sipCpp->GetPointClassification( aPnt, aRef );
    Py_END_ALLOW_THREADS
  %End


  void ClearRules();

  void AddRule( HYDROData_Object                   theObject1,
                HYDROData_PriorityType             thePriority,
                HYDROData_Object                   theObject2,
                HYDROData_Zone::MergeAltitudesType theMergeType )
  [void ( const Handle_HYDROData_Object&, HYDROData_PriorityType, const Handle_HYDROData_Object&, HYDROData_Zone::MergeAltitudesType )];
  %MethodCode
    Handle(HYDROData_Object) anObject1 =
      Handle(HYDROData_Object)::DownCast( createHandle( a0 ) );
    Handle(HYDROData_Object) anObject2 =
      Handle(HYDROData_Object)::DownCast( createHandle( a2 ) );

    Py_BEGIN_ALLOW_THREADS
    sipSelfWasArg ? sipCpp->HYDROData_CalculationCase::AddRule( anObject1, a1, anObject2, a3 ) : 
                    sipCpp->AddRule( anObject1, a1, anObject2, a3 );
    Py_END_ALLOW_THREADS
  %End

  QString DumpRules();

  void SetAssignmentMode( AssignmentMode theMode );
  AssignmentMode GetAssignmentMode() const;

protected:

  /**
   * Creates new object in the internal data structure. Use higher level objects 
   * to create objects with real content.
   */
  HYDROData_CalculationCase();

  /**
   * Destructs properties of the object and object itself, removes it from the document.
   */
  ~HYDROData_CalculationCase();
};