/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_drawinglayer.hxx"

#include <drawinglayer/primitive3d/hatchtextureprimitive3d.hxx>
#include <drawinglayer/primitive3d/polypolygonprimitive3d.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/polygon/b3dpolygon.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/polygon/b2dpolypolygontools.hxx>
#include <basegfx/range/b2drange.hxx>
#include <drawinglayer/texture/texture.hxx>
#include <basegfx/polygon/b2dpolygonclipper.hxx>
#include <basegfx/matrix/b3dhommatrix.hxx>
#include <drawinglayer/primitive3d/polygonprimitive3d.hxx>
#include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>

//////////////////////////////////////////////////////////////////////////////

using namespace com::sun::star;

//////////////////////////////////////////////////////////////////////////////

namespace drawinglayer
{
	namespace primitive3d
	{
		Primitive3DSequence HatchTexturePrimitive3D::impCreate3DDecomposition() const
		{
			Primitive3DSequence aRetval;

			if(getChildren().hasElements())
			{
				const Primitive3DSequence aSource(getChildren());
				const sal_uInt32 nSourceCount(aSource.getLength());
				std::vector< Primitive3DReference > aDestination;

				for(sal_uInt32 a(0); a < nSourceCount; a++)
				{
					// get reference
					const Primitive3DReference xReference(aSource[a]);

					if(xReference.is())
					{
						// try to cast to BasePrimitive2D implementation
						const BasePrimitive3D* pBasePrimitive = dynamic_cast< const BasePrimitive3D* >(xReference.get());

						if(pBasePrimitive)
						{
							// it is a BasePrimitive3D implementation, use getPrimitive3DID() call for switch
							// not all content is needed, remove transparencies and ModifiedColorPrimitives
							switch(pBasePrimitive->getPrimitive3DID())
							{
								case PRIMITIVE3D_ID_POLYPOLYGONMATERIALPRIMITIVE3D :
								{
									// polyPolygonMaterialPrimitive3D, check texturing and hatching
									const PolyPolygonMaterialPrimitive3D& rPrimitive = static_cast< const PolyPolygonMaterialPrimitive3D& >(*pBasePrimitive);
									const basegfx::B3DPolyPolygon aFillPolyPolygon(rPrimitive.getB3DPolyPolygon());

									if(maHatch.isFillBackground())
									{
										// add original primitive for background
										aDestination.push_back(xReference);
									}
									
									if(aFillPolyPolygon.areTextureCoordinatesUsed())
									{
										const sal_uInt32 nPolyCount(aFillPolyPolygon.count());
										basegfx::B2DPolyPolygon aTexPolyPolygon;
										basegfx::B2DPoint a2N;
										basegfx::B2DVector a2X, a2Y;
										basegfx::B3DPoint a3N;
										basegfx::B3DVector a3X, a3Y;
										bool b2N(false), b2X(false), b2Y(false);

										for(sal_uInt32 b(0); b < nPolyCount; b++)
										{
											const basegfx::B3DPolygon aPartPoly(aFillPolyPolygon.getB3DPolygon(b));
											const sal_uInt32 nPointCount(aPartPoly.count());
											basegfx::B2DPolygon aTexPolygon;

											for(sal_uInt32 c(0); c < nPointCount; c++)
											{
												const basegfx::B2DPoint a2Candidate(aPartPoly.getTextureCoordinate(c));

												if(!b2N)
												{
													a2N = a2Candidate;
													a3N = aPartPoly.getB3DPoint(c);
													b2N = true;
												}
												else if(!b2X && !a2N.equal(a2Candidate))
												{
													a2X = a2Candidate - a2N;
													a3X = aPartPoly.getB3DPoint(c) - a3N;
													b2X = true;
												}
												else if(!b2Y && !a2N.equal(a2Candidate) && !a2X.equal(a2Candidate))
												{
													a2Y = a2Candidate - a2N;
													
													const double fCross(a2X.cross(a2Y));

													if(!basegfx::fTools::equalZero(fCross))
													{
														a3Y = aPartPoly.getB3DPoint(c) - a3N;
														b2Y = true;
													}
												}

												aTexPolygon.append(a2Candidate);
											}

											aTexPolygon.setClosed(true);
											aTexPolyPolygon.append(aTexPolygon);
										}

										if(b2N && b2X && b2Y)
										{
											// found two linearly independent 2D vectors
											// get 2d range of texture coordinates
											const basegfx::B2DRange aOutlineRange(basegfx::tools::getRange(aTexPolyPolygon));
											const basegfx::BColor aHatchColor(getHatch().getColor());
											const double fAngle(getHatch().getAngle());
											::std::vector< basegfx::B2DHomMatrix > aMatrices;

											// get hatch transformations
											switch(getHatch().getStyle())
											{
												case attribute::HATCHSTYLE_TRIPLE:
												{
													// rotated 45 degrees
													texture::GeoTexSvxHatch aHatch(aOutlineRange, getHatch().getDistance(), fAngle - F_PI4);
													aHatch.appendTransformations(aMatrices);
												}
												case attribute::HATCHSTYLE_DOUBLE:
												{
													// rotated 90 degrees
													texture::GeoTexSvxHatch aHatch(aOutlineRange, getHatch().getDistance(), fAngle - F_PI2);
													aHatch.appendTransformations(aMatrices);
												}
												case attribute::HATCHSTYLE_SINGLE:
												{
													// angle as given
													texture::GeoTexSvxHatch aHatch(aOutlineRange, getHatch().getDistance(), fAngle);
													aHatch.appendTransformations(aMatrices);
												}
											}

											// create geometry from unit line
											basegfx::B2DPolyPolygon a2DHatchLines;
											basegfx::B2DPolygon a2DUnitLine;
											a2DUnitLine.append(basegfx::B2DPoint(0.0, 0.0));
											a2DUnitLine.append(basegfx::B2DPoint(1.0, 0.0));

											for(sal_uInt32 c(0); c < aMatrices.size(); c++)
											{
												const basegfx::B2DHomMatrix& rMatrix = aMatrices[c];
												basegfx::B2DPolygon aNewLine(a2DUnitLine);
												aNewLine.transform(rMatrix);
												a2DHatchLines.append(aNewLine);
											}

											if(a2DHatchLines.count())
											{
												// clip against texture polygon
												a2DHatchLines = basegfx::tools::clipPolyPolygonOnPolyPolygon(a2DHatchLines, aTexPolyPolygon, true, true);
											}

											if(a2DHatchLines.count())
											{
												// create 2d matrix with 2d vectors as column vectors and 2d point as offset, this represents
												// a coordinate system transformation from unit coordinates to the new coordinate system
												basegfx::B2DHomMatrix a2D;
												a2D.set(0, 0, a2X.getX());
												a2D.set(1, 0, a2X.getY());
												a2D.set(0, 1, a2Y.getX());
												a2D.set(1, 1, a2Y.getY());
												a2D.set(0, 2, a2N.getX());
												a2D.set(1, 2, a2N.getY());

												// invert that transformation, so we have a back-transformation from texture coordinates
												// to unit coordinates
												a2D.invert();
												a2DHatchLines.transform(a2D);

												// expand back-transformated geometry tpo 3D
												basegfx::B3DPolyPolygon a3DHatchLines(basegfx::tools::createB3DPolyPolygonFromB2DPolyPolygon(a2DHatchLines, 0.0));

												// create 3d matrix with 3d vectors as column vectors (0,0,1 as Z) and 3d point as offset, this represents
												// a coordinate system transformation from unit coordinates to the object's 3d coordinate system
												basegfx::B3DHomMatrix a3D;
												a3D.set(0, 0, a3X.getX());
												a3D.set(1, 0, a3X.getY());
												a3D.set(2, 0, a3X.getZ());
												a3D.set(0, 1, a3Y.getX());
												a3D.set(1, 1, a3Y.getY());
												a3D.set(2, 1, a3Y.getZ());
												a3D.set(0, 3, a3N.getX());
												a3D.set(1, 3, a3N.getY());
												a3D.set(2, 3, a3N.getZ());

												// transform hatch lines to 3D object coordinates
												a3DHatchLines.transform(a3D);

												// build primitives from this geometry
												const sal_uInt32 nHatchLines(a3DHatchLines.count());

												for(sal_uInt32 d(0); d < nHatchLines; d++)
												{
													const Primitive3DReference xRef(new PolygonHairlinePrimitive3D(a3DHatchLines.getB3DPolygon(d), aHatchColor));
													aDestination.push_back(xRef);
												}
											}
										}
									}

									break;
								}
								default :
								{
									// add reference to result
									aDestination.push_back(xReference);
									break;
								}
							}
						}
						else
						{
							// unknown implementation, add to result
							aDestination.push_back(xReference);
						}
					}
				}

				// prepare return value
				const sal_uInt32 nDestSize(aDestination.size());
				aRetval.realloc(nDestSize);

				for(sal_uInt32 b(0); b < nDestSize; b++)
				{
					aRetval[b] = aDestination[b];
				}
			}

			return aRetval;
		}

		HatchTexturePrimitive3D::HatchTexturePrimitive3D(
			const attribute::FillHatchAttribute& rHatch, 
			const Primitive3DSequence& rChildren, 
			const basegfx::B2DVector& rTextureSize, 
			bool bModulate, 
			bool bFilter)
		:	TexturePrimitive3D(rChildren, rTextureSize, bModulate, bFilter),
			maHatch(rHatch),
            maBuffered3DDecomposition()
		{
		}

		bool HatchTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
		{
			if(TexturePrimitive3D::operator==(rPrimitive))
			{
				const HatchTexturePrimitive3D& rCompare = (HatchTexturePrimitive3D&)rPrimitive;
				
				return (getHatch() == rCompare.getHatch());
			}

			return false;
		}

        Primitive3DSequence HatchTexturePrimitive3D::get3DDecomposition(const geometry::ViewInformation3D& /*rViewInformation*/) const
        {
			::osl::MutexGuard aGuard( m_aMutex );

			if(!getBuffered3DDecomposition().hasElements())
			{
				const Primitive3DSequence aNewSequence(impCreate3DDecomposition());
				const_cast< HatchTexturePrimitive3D* >(this)->setBuffered3DDecomposition(aNewSequence);
			}

			return getBuffered3DDecomposition();
        }

		// provide unique ID
		ImplPrimitrive3DIDBlock(HatchTexturePrimitive3D, PRIMITIVE3D_ID_HATCHTEXTUREPRIMITIVE3D)

	} // end of namespace primitive3d
} // end of namespace drawinglayer

//////////////////////////////////////////////////////////////////////////////
// eof