/********************************************************************************
 *                                                                              *
 * This file is part of IfcOpenShell.                                           *
 *                                                                              *
 * IfcOpenShell is free software: you can redistribute it and/or modify         *
 * it under the terms of the Lesser GNU General Public License as published by  *
 * the Free Software Foundation, either version 3.0 of the License, or          *
 * (at your option) any later version.                                          *
 *                                                                              *
 * IfcOpenShell 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                 *
 * Lesser GNU General Public License for more details.                          *
 *                                                                              *
 * You should have received a copy of the Lesser GNU General Public License     *
 * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
 *                                                                              *
 ********************************************************************************/

#include <string>
#include <iostream>
#include <fstream>

#include <TColgp_Array2OfPnt.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>

#include <Geom_BSplineSurface.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <Standard_Version.hxx>

#include <BRepGProp.hxx>
#include <GProp_GProps.hxx>

#include <Precision.hxx>

#define IfcSchema Ifc2x3
#include "../ifcparse/macros.h"
#include "../ifcparse/schemas/Ifc2x3.h"
#include "../ifcparse/hierarchy_helper.h"

#include "../ifcgeom/Serialization/Serialization.h"

#if USE_VLD
#include <vld.h>
#endif

using namespace std::string_literals;

// Some convenience typedefs and definitions. 
typedef ifcopenshell::global_id guid;
typedef std::pair<double, double> XY;
boost::none_t const null = boost::none;

// The creation of Nurbs-surface for the IfcSite mesh, to be implemented lateron
void createGroundShape(TopoDS_Shape& shape);

int main() {

    // The hierarchy_helper is a subclass of the regular file that provides several
    // convenience functions for working with geometry in IFC files.
    hierarchy_helper<IfcSchema> file;
    file.header().file_name().setname("IfcOpenHouse.ifc");

    // Start by adding a wall to the file, initially leaving most attributes blank.
    auto south_wall = file.create<IfcSchema::IfcWallStandardCase>();
    south_wall.setGlobalId(guid());
    south_wall.setName("South wall");
#ifdef USE_IFC4
    south_wall.setPredefinedType(IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD);
#endif
    file.addBuildingProduct(south_wall);

    // By adding a wall, a hierarchy has been automatically created that consists of the following
    // structure: IfcProject > IfcSite > IfcBuilding > IfcBuildingStorey > IfcWall

    // Lateron changing the name of the IfcProject can be done by obtaining a reference to the
    // project, which has been created automatically.
    file.getSingle<IfcSchema::IfcProject>().setName("IfcOpenHouse"s);

    // An IfcOwnerHistory has been initialized as well, which should be assigned to the wall.
    south_wall.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());

    // The wall will be shaped as a box, with the dimensions specified in millimeters. The resulting
    // product definition will consist of both a body representation as well as an axis representation
    // that runs over the centerline of the box in the X-axis.
    auto south_wall_shape = file.addAxisBox(10000, 360, 3000);

    // Obtain a reference to the placement of the IfcBuildingStorey in order to create a hierarchy
    // of placements for the products
    auto storey_placement = file.getSingle<IfcSchema::IfcBuildingStorey>().ObjectPlacement();

    // The shape has to be assigned to the representation of the wall and is placed at the origin
    // of the coordinate system.
    south_wall.setRepresentation(south_wall_shape);
    south_wall.setObjectPlacement(file.addLocalPlacement(storey_placement));

    // A pale white colour is assigned to the wall.
    auto wall_colour = setSurfaceColour(file, south_wall_shape, 0.75, 0.73, 0.68);

    // Now create a footing for the wall to rest on.
    auto footing = file.create<IfcSchema::IfcFooting>();
    footing.setGlobalId(guid());
    footing.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    footing.setName("Footing");
    footing.setPredefinedType(IfcSchema::IfcFootingTypeEnum::IfcFootingType_STRIP_FOOTING);

    file.addBuildingProduct(footing);

    // The footing will span the entire floor plan of our building. The IfcRepresentationContext is
    // something that has been created automatically as well, but representations could have been
    // assigned to a specific context, for example to add a two dimensional plan representation as well.
    footing.setRepresentation(file.addBox(10100, 5460, 2000));
    footing.setObjectPlacement(file.addLocalPlacement(storey_placement, 0, 2500, -2000));
    // The footing will have a dark gray colour
    auto footing_colour = setSurfaceColour(file, footing.Representation(), 0.26, 0.22, 0.18);

    // IFC has two ways to apply boolean operations to geometry. IfcBooleanResults are commonly used
    // to clip geometry to a surface, for example to a slanted roof. For openings that are filled
    // with another element, for example a door or a window, an IfcOpeningElement is used instead.

    // An opening element is created with rectangular geometry:
    auto west_opening = file.create<IfcSchema::IfcOpeningElement>();
    west_opening.setGlobalId(guid());
    west_opening.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    west_opening.setObjectPlacement(file.addLocalPlacement(south_wall.ObjectPlacement(), -2500, 0, 400));
    west_opening.setRepresentation(file.addBox(6000, 3630, 1600));
#ifdef USE_IFC4
    west_opening.setPredefinedType(IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING);
#endif

    // Relate the opening element to the wall.
    auto void_element = file.create<IfcSchema::IfcRelVoidsElement>();
    void_element.setGlobalId(guid());
    void_element.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    void_element.setRelatingBuildingElement(south_wall);
    void_element.setRelatedOpeningElement(west_opening);

    // Now create an additional opening
    auto south_opening = file.create<IfcSchema::IfcOpeningElement>();
    south_opening.setGlobalId(guid());
    south_opening.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    south_opening.setObjectPlacement(file.addLocalPlacement(storey_placement, 3000, 0, 400));
    south_opening.setRepresentation(file.addBox(1860, 3000, 1600));
#ifdef USE_IFC4
    south_opening.setPredefinedType(IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING);
#endif

    // Relate the opening element to the wall.
    auto void_element2 = file.create<IfcSchema::IfcRelVoidsElement>();
    void_element2.setGlobalId(guid());
    void_element2.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    void_element2.setRelatingBuildingElement(south_wall);
    void_element2.setRelatedOpeningElement(south_opening);

    // Create a roof element that will consist of two slabs:
    auto roof = file.create<IfcSchema::IfcRoof>();
    roof.setGlobalId(guid());
    roof.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    roof.setName("Roof");
    roof.setObjectPlacement(file.addLocalPlacement(storey_placement));
#ifdef USE_IFC4
    roof.setPredefinedType(IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
#else
    roof.setShapeType(IfcSchema::IfcRoofTypeEnum::IfcRoofType_GABLE_ROOF);
#endif

    // The roof geometry is slanted 45 degrees by specifying a direction for the box extrusion
    auto roof_rep = file.addEmptyRepresentation();
    file.addBox(roof_rep, 10200, 360, sqrt(2.0 * 2900 * 2900), IfcSchema::IfcAxis2Placement2D{}, file.addPlacement3d(0, 0, 0, 0, 1, 0), file.addTriplet<IfcSchema::IfcDirection>(0, -sqrt(0.5), sqrt(0.5)));

    // CV-2x3-144: Roofs are aggregates and shall have at least one contained element and no own geometry
    auto south_roof_part = file.create<IfcSchema::IfcSlab>();
    south_roof_part.setGlobalId(guid());
    south_roof_part.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    south_roof_part.setName("South roof");
    south_roof_part.setPredefinedType(IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);

    // The geometry is instantiated by using IfcMappedItems. This way geometry definitions can
    // be reused while maintaining the cardinality constraint that the ShapeOfProduct relation
    // imposes on the IfcProductDefinitionShape. Note that this constrained is lifted in IFC4.
    south_roof_part.setRepresentation(file.addMappedItem(roof_rep));
    south_roof_part.setObjectPlacement(file.addLocalPlacement(roof.ObjectPlacement(), 0, -400, 2700));

    // The same roof geometry is re-used on the north side of the roof, by inverting the X-axis of
    // the local placement the roof is rotated 180 degrees around the Z-axis
    auto north_roof_part = file.create<IfcSchema::IfcSlab>();
    north_roof_part.setGlobalId(guid());
    north_roof_part.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    north_roof_part.setName("North roof");
    north_roof_part.setPredefinedType(IfcSchema::IfcSlabTypeEnum::IfcSlabType_ROOF);

    north_roof_part.setRepresentation(file.addMappedItem(roof_rep));
    north_roof_part.setObjectPlacement(file.addLocalPlacement(roof.ObjectPlacement(), 0, 5400, 2700, 0, 0, 1, -1, 0, 0));

    {
        auto rel = file.create<IfcSchema::IfcRelAggregates>();
        rel.setGlobalId(guid());
        rel.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
        rel.setRelatingObject(roof);
        rel.setRelatedObjects({south_roof_part, north_roof_part});
    }

    file.addBuildingProduct(south_roof_part);
    file.addBuildingProduct(north_roof_part);
    file.addBuildingProduct(roof);

    setSurfaceColour(file, roof_rep, 0.24, 0.08, 0.04);

    // Copy the south wall to the north
    auto north_wall = file.create<IfcSchema::IfcWallStandardCase>();
    north_wall.setGlobalId(guid());
    north_wall.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    north_wall.setName("North wall");
    north_wall.setObjectPlacement(file.addLocalPlacement(storey_placement, 0, 5000, 0));
    north_wall.setRepresentation(file.addAxisBox(10000, 360, 3000));
#ifdef USE_IFC4
    north_wall.setPredefinedType(IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD);
#endif

    file.addBuildingProduct(north_wall);
    setSurfaceColour(file, north_wall.Representation(), wall_colour);

    // Two identical representations are created for the two remaining walls. Mapped items
    // are not used, because it is not allowed by the standard for wall body representations.
    // MappedItems are not allowed for Axis representations as per CV-2x3-161
    IfcSchema::IfcProductDefinitionShape clipped_wall_body_reps[2];
    for (int i = 0; i < 2; ++i) {
        auto body = file.addEmptyRepresentation();
        file.addBox(body, 5000, 360, 6000);
        // The wall geometry is clipped using two IfcHalfSpaceSolids, created from an
        // 'axis 3d placement' that specifies the plane against which the geometry is clipped.
        file.clipRepresentation(body, file.addPlacement3d(-2500, 0, 3000, -1, 0, 1), false);
        file.clipRepresentation(body, file.addPlacement3d(2500, 0, 3000, 1, 0, 1), false);
        setSurfaceColour(file, body, wall_colour);

        auto axis = file.addEmptyRepresentation("Axis", "Curve2D");
        file.addAxis(axis, 5000);

        clipped_wall_body_reps[i] = file.create<IfcSchema::IfcProductDefinitionShape>();
        clipped_wall_body_reps[i].setRepresentations({body, axis});
    }

    // Now create a wall on the east of the building, again starting with just a box shape
    auto east_wall = file.create<IfcSchema::IfcWallStandardCase>();
    east_wall.setGlobalId(guid());
    east_wall.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    east_wall.setName("East wall");
    east_wall.setObjectPlacement(file.addLocalPlacement(storey_placement, 4820, 2500, 0, 0, 0, 1, 0, 1, 0));
    east_wall.setRepresentation(clipped_wall_body_reps[0]);
#ifdef USE_IFC4
    east_wall.setPredefinedType(IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD);
#endif

    file.addBuildingProduct(east_wall);

    // The east wall is copied to the west location of the house
    auto west_wall = file.create<IfcSchema::IfcWallStandardCase>();
    west_wall.setGlobalId(guid());
    west_wall.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    west_wall.setName("West wall");
    west_wall.setObjectPlacement(file.addLocalPlacement(storey_placement, -4820, 2500, 0, 0, 0, 1, 0, -1, 0));
    west_wall.setRepresentation(clipped_wall_body_reps[1]);
#ifdef USE_IFC4
    west_wall.setPredefinedType(IfcSchema::IfcWallTypeEnum::IfcWallType_STANDARD);
#endif

    file.addBuildingProduct(west_wall);

    // The west wall is assigned an opening element we created for the south wall, opening elements are
    // not shared across building elements, even if they share the same representation. Hence, the east
    // wall will not feature this opening.
    // NB: an Opening Element can only be used to create a single void within a single Element, as per:
    // http://www.buildingsmart-tech.org/ifc/IFC2x3/TC1/html/ifcproductextension/lexical/ifcfeatureelementsubtraction.htm

    // Not all viewers support opening elements with mapped representations, hence an exact copy of the
    // same subtraction box is instantiated for the otherwise identical opening element.
    auto west_opening_copy = file.create<IfcSchema::IfcOpeningElement>();
    west_opening_copy.setGlobalId(guid());
    west_opening_copy.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    west_opening_copy.setObjectPlacement(file.addLocalPlacement(west_wall.ObjectPlacement(), 2500, -2500 + 4820, 400, 0, 0, 1, 0, 1, 0));
    west_opening_copy.setRepresentation(file.addBox(6000, 3630, 1600));
#ifdef USE_IFC4
    west_opening_copy.setPredefinedType(IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING);
#endif

    {
        auto rel = file.create<IfcSchema::IfcRelVoidsElement>();
        rel.setGlobalId(guid());
        rel.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
        rel.setRelatingBuildingElement(west_wall);
        rel.setRelatedOpeningElement(west_opening_copy);
    }

	// Up until now we have only used simple extrusions for the creation of the geometry. For the 
	// ground mesh of the IfcSite we will use a Nurbs surface created in Open Cascade. The surface 
	// will be tessellated using the deflection specified.
	TopoDS_Shape shape;
	createGroundShape(shape);
	auto ground_representation = IfcGeom::tesselate(file, shape, 100.).as<IfcSchema::IfcProductDefinitionShape>();
	file.getSingle<IfcSchema::IfcSite>().setRepresentation(ground_representation);

	GProp_GProps prop;
	BRepGProp::SurfaceProperties(shape, prop);
	const double site_area = prop.Mass() / 1000 / 1000;

    auto total_area = file.create<IfcSchema::IfcPropertySingleValue>();
    total_area.setName("TotalArea");
    auto area = file.create<IfcSchema::IfcAreaMeasure>();
    area.set_attribute_value(0, site_area);
    total_area.setNominalValue(area);

	auto pset = file.create<IfcSchema::IfcPropertySet>();
    pset.setGlobalId(guid());
    pset.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    pset.setName("Pset_SiteCommon");
    pset.setHasProperties({total_area});

	auto site_prop = file.create<IfcSchema::IfcRelDefinesByProperties>();
    site_prop.setGlobalId(guid());
    site_prop.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    site_prop.setRelatedObjects({file.getSingle<IfcSchema::IfcSite>()});
    site_prop.setRelatingPropertyDefinition(pset);
	
	auto ground_reps = file.getSingle<IfcSchema::IfcSite>().Representation().Representations();
    for (auto& rep : ground_reps) {
        rep.setContextOfItems(file.getRepresentationContext("Model"));
	}
	file.add_entity(ground_representation);
	setSurfaceColour(file,ground_representation, 0.15, 0.25, 0.05);

	// According to the Ifc2x3 schema an IfcWallStandardCase needs to have an IfcMaterialLayerSet
	// assigned. Note that this material definition is independent of the surface styles we have 
	// been assigning to the walls already. The surface styles determine the colour in the 
	// '3D viewport' of most applications.
	// Some BIM authoring applications, such as Autodesk Revit, ignore the geometrical representation
	// by and large and construct native walls using the layer thickness and reference line offset 
	// provided here.
    auto material = file.create<IfcSchema::IfcMaterial>();
    material.setName("Brick");

	auto layer = file.create<IfcSchema::IfcMaterialLayer>();
    layer.setMaterial(material);
    layer.setLayerThickness(360);

	auto layer_set = file.create<IfcSchema::IfcMaterialLayerSet>();
    layer_set.setMaterialLayers({layer});
    layer_set.setLayerSetName("Wall");

	auto layer_usage = file.create<IfcSchema::IfcMaterialLayerSetUsage>();
    layer_usage.setForLayerSet(layer_set);
	layer_usage.setDirectionSense(IfcSchema::IfcDirectionSenseEnum::IfcDirectionSense_POSITIVE);
	layer_usage.setLayerSetDirection(IfcSchema::IfcLayerSetDirectionEnum::IfcLayerSetDirection_AXIS1);
    layer_usage.setOffsetFromReferenceLine(-180);

	auto associates_material = file.create<IfcSchema::IfcRelAssociatesMaterial>();
    associates_material.setGlobalId(guid());
	associates_material.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
	associates_material.setRelatedObjects({south_wall, north_wall, east_wall, west_wall});
    associates_material.setRelatingMaterial(layer_usage);

	// In addition, another common way to represent geometry in IFC files is to use extrusions of
	// planar areas bounded by a polygon.
	std::vector<XY> stair_points;
	stair_points.push_back(XY(  0,  0));
	stair_points.push_back(XY(250,  0));
	stair_points.push_back(XY(250, 200));
	stair_points.push_back(XY(500, 200));
	stair_points.push_back(XY(500, 400));
	stair_points.push_back(XY(  0, 400));
    auto stair = file.create<IfcSchema::IfcStairFlight>();
    stair.setGlobalId(guid());
    stair.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    stair.setObjectPlacement(file.addLocalPlacement(storey_placement, 5050, 1000, 0, 0, 1, 0, 1, 0, 0));
    stair.setRepresentation(file.addExtrudedPolyline(stair_points, 1200));
#ifdef USE_IFC4
    stair.setNumberOfRisers(2);
#else
    stair.setNumberOfRiser(2);
#endif
    stair.setNumberOfTreads(2);
    stair.setRiserHeight(0.2);
    stair.setTreadLength(0.25);
#ifdef USE_IFC4
    stair.setPredefinedType(IfcSchema::IfcStairFlightTypeEnum::IfcStairFlightType_STRAIGHT);
#endif

	file.addBuildingProduct(stair);
	setSurfaceColour(file, stair.Representation(), footing_colour);

	auto door_opening = file.create<IfcSchema::IfcOpeningElement>();
    door_opening.setGlobalId(guid());
    door_opening.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    door_opening.setObjectPlacement(file.addLocalPlacement(storey_placement, 5000 - 180, 2500 - 900, 0));
    door_opening.setRepresentation(file.addBox(1000, 1000, 2200));
#ifdef USE_IFC4
    door_opening.setPredefinedType(IfcSchema::IfcOpeningElementTypeEnum::IfcOpeningElementType_OPENING);
#endif

    auto rel3 = file.create<IfcSchema::IfcRelVoidsElement>();
    rel3.setGlobalId(guid());
    rel3.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    rel3.setRelatingBuildingElement(east_wall);
    rel3.setRelatedOpeningElement(door_opening);

	// A single shape representation can contain multiple representiation items. This way a product
	// can be a composition of multiple solids. The following door will be composed of four boxes
	// which constitute the door and its frame.
    auto door = file.create<IfcSchema::IfcDoor>();
    door.setGlobalId(guid());
    door.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    door.setObjectPlacement(file.addLocalPlacement(storey_placement, 4800, 1600, 0, 0, 0, 1, 0, 1, 0));
    door.setOverallWidth(1000);
    door.setOverallHeight(2200);
#ifdef USE_IFC4
    door.setPredefinedType(IfcSchema::IfcDoorTypeEnum::IfcDoorType_DOOR);
    door.setOperationType(IfcSchema::IfcDoorTypeOperationEnum::IfcDoorTypeOperation_SINGLE_SWING_LEFT);
#endif

    door.setRepresentation(file.addBox(80, 80, 2120, IfcSchema::IfcAxis2Placement2D{}, file.addPlacement3d(460, 0, 0)));
    
    auto door_representations = door.Representation().Representations();
    IfcSchema::IfcShapeRepresentation door_body;
	for (auto& rep : door_representations) {
		if (rep.declaration().is(IfcSchema::IfcShapeRepresentation::Class()) && rep.RepresentationIdentifier().value_or("") == "Body") {
            door_body = rep.as<IfcSchema::IfcShapeRepresentation>();
		}
	}

	file.addBox(door_body,  80, 80, 2120, IfcSchema::IfcAxis2Placement2D{}, file.addPlacement3d(-460, 0,   0));
	file.addBox(door_body, 1000, 80,  80, IfcSchema::IfcAxis2Placement2D{}, file.addPlacement3d(   0, 0, 2120));
	file.addBox(door_body, 860, 30, 2120);
	file.addBuildingProduct(door);

	setSurfaceColour(file, door.Representation(), 0.9, 0.9, 0.9);
    {
        auto rel = file.create<IfcSchema::IfcRelFillsElement>();
        rel.setGlobalId(guid());
        rel.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
        rel.setRelatingOpeningElement(door_opening);
        rel.setRelatedBuildingElement(door);
    }

	auto door_style = file.create<IfcSchema::IfcDoorStyle>();
    door_style.setGlobalId(guid());
    door_style.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
    door_style.setName("Door type");
    door_style.setOperationType(IfcSchema::IfcDoorStyleOperationEnum::IfcDoorStyleOperation_SINGLE_SWING_LEFT);
    door_style.setConstructionType(IfcSchema::IfcDoorStyleConstructionEnum::IfcDoorStyleConstruction_WOOD);
    door_style.setParameterTakesPrecedence(false);
    door_style.setSizeable(false);

	// NOTE: typing by IfcDoorStyle will cause validation errors in IFC4+ but it's allowed for backwards compatibility
	// better to use IfcDoorType in the actual use case
	file.addRelatedObject<IfcSchema::IfcRelDefinesByType>(door_style, door);

	// Surface styles are assigned to representation items, hence there is no real limitation to
	// assign different colours within the same representation. However, some viewers have 
	// difficulties rendering products with representation items with different surface styles. 
	// Therefore we will construct the window as a decomposition of beams and a plate, in which 
	// only the plate will have a transparent material assigned.

	// The window frame will consists of four separate beams.
	// AutoCAD Architecture will create an internal window type for the IfcWindow created.
	// Therefore the OverallWidth and OverallHeight of the window attributes will need to
	// match the bounding box of the representation. Furthermore, the window placement needs
	// to align with the lowerleft corner of the constituent parts.
    std::vector<IfcSchema::IfcShapeRepresentation> frame_representations;
	
	auto horizontal_bar = file.addEmptyRepresentation();
	auto vertical_bar = file.addEmptyRepresentation();
	file.addBox(horizontal_bar, 1860, 90, 90);
	file.addBox(vertical_bar, 90, 90, 1420);

	frame_representations.push_back(horizontal_bar);
	frame_representations.push_back(horizontal_bar); // Add another reference to the horizontal bar created above
	frame_representations.push_back(vertical_bar);
	frame_representations.push_back(vertical_bar); // Add another reference to the vertical bar created above

	// The beams all have the same surface style assigned
    IfcSchema::IfcPresentationStyleAssignment frame_style;
	for (auto i = frame_representations.begin(); i != frame_representations.end(); i += 2) {
		if (frame_style) {
			setSurfaceColour(file, *i, frame_style);
		} else {
			frame_style = setSurfaceColour(file,*i, 0.5, 0.4, 0.3);
		}
		// Because of the duplication the iterator is incremented twice
	}

	// This window will be placed at five locations within the building. A list of placements is 
	// created and is iterated over to create all window instances.
    std::vector<IfcSchema::IfcLocalPlacement> window_placements;
	window_placements.push_back(file.addLocalPlacement(storey_placement, 2*-1770-430-930,   -45, 400));
	window_placements.push_back(file.addLocalPlacement(storey_placement,   -1770-430-930,   -45, 400));
	window_placements.push_back(file.addLocalPlacement(storey_placement,        -430-930,   -45, 400));
	window_placements.push_back(file.addLocalPlacement(storey_placement,        3000-930,   -45, 400));
	window_placements.push_back(file.addLocalPlacement(storey_placement, -4855+45, 885-930, 400, 0, 0, 1, 0, 1, 0));
	
	for (auto& place : window_placements) {
        auto window = file.create<IfcSchema::IfcWindow>();
        window.setGlobalId(guid());
        window.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
        window.setObjectPlacement(place);
        window.setOverallWidth(1860);
        window.setOverallHeight(1600);
#ifdef USE_IFC4
        window.setPredefinedType(IfcSchema::IfcWindowTypeEnum::IfcWindowType_WINDOW);
        window.setPartitioningType(IfcSchema::IfcWindowTypePartitioningEnum::IfcWindowTypePartitioning_SINGLE_PANEL);
#endif
        file.addBuildingProduct(window);		

		// Initialize a list of parts for the window to be composed of
        std::vector<IfcSchema::IfcObjectDefinition> window_parts;

		// The placements for the beams are not shared across the different windows because every
		// beam is placed relative to its parent window entity.
        std::vector<IfcSchema::IfcLocalPlacement> frame_placements;
		frame_placements.push_back(file.addLocalPlacement(storey_placement,  930,45));
		frame_placements.push_back(file.addLocalPlacement(storey_placement,  930, 45, 1510));
		frame_placements.push_back(file.addLocalPlacement(storey_placement, -885+930, 45,  90));
		frame_placements.push_back(file.addLocalPlacement(storey_placement,  885+930, 45,  90));
		
		// Now iterate over the placements and representations of the beam and add them to list of parts
        std::vector<IfcSchema::IfcLocalPlacement>::const_iterator frame_placement;
        std::vector<IfcSchema::IfcShapeRepresentation>::const_iterator frame_representation;
		for (frame_placement = frame_placements.begin(), frame_representation = frame_representations.begin();
			frame_placement != frame_placements.end() && frame_representation != frame_representations.end();
			++frame_placement, ++frame_representation)
		{
            auto frame_part = file.create<IfcSchema::IfcMember>();
            frame_part.setGlobalId(guid());
            frame_part.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
            frame_part.setObjectPlacement(*frame_placement);
            frame_part.setRepresentation(file.addMappedItem(*frame_representation));
#ifdef USE_IFC4
            frame_part.setPredefinedType(IfcSchema::IfcMemberTypeEnum::IfcMemberType_MULLION);
#endif
			window_parts.push_back(frame_part);
			file.relatePlacements(window, frame_part);
		}

		// Add the glass plate to the list of parts
        auto glass_part = file.create<IfcSchema::IfcPlate>();
        glass_part.setGlobalId(guid());
        glass_part.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
        glass_part.setObjectPlacement(file.addLocalPlacement(storey_placement, 930, 45, 90));
        glass_part.setRepresentation(file.addBox(1860, 10, 1420));
#ifdef USE_IFC4
        glass_part.setPredefinedType(IfcSchema::IfcPlateTypeEnum::IfcPlateType_SHEET);
#endif

        window_parts.push_back(glass_part);
		file.relatePlacements(window, glass_part);
		setSurfaceColour(file, glass_part.Representation(), 0.6, 0.7, 0.75, 0.1);
		
		// Now create a decomposition relation between the window and the parts. Most viewers and authoring
		// tools will consider the window a single entity that can be selected as a whole.
        {

            auto rel = file.create<IfcSchema::IfcRelAggregates>();
            rel.setGlobalId(guid());
            rel.setOwnerHistory(file.getSingle<IfcSchema::IfcOwnerHistory>());
            rel.setRelatingObject(window);
            rel.setRelatedObjects(window_parts);
        }
	}

	// Finally create a file stream for our output and write the IFC file to it.
	std::ofstream f("IfcOpenHouse.ifc");
	f << file;
}

void createGroundShape(TopoDS_Shape& shape) {
	TColgp_Array2OfPnt cv (0, 4, 0, 4);
	cv.SetValue(0, 0, gp_Pnt(-10000, -10000, -4130));
	cv.SetValue(0, 1, gp_Pnt(-10000,  -4330, -4130));
	cv.SetValue(0, 2, gp_Pnt(-10000,      0, -5130));
	cv.SetValue(0, 3, gp_Pnt(-10000,   4330, -7130));
	cv.SetValue(0, 4, gp_Pnt(-10000,  10000, -7130));
	cv.SetValue(1, 0, gp_Pnt( -3330, -10000, -5130));
	cv.SetValue(1, 1, gp_Pnt( -7670,  -3670,  5000));
	cv.SetValue(1, 2, gp_Pnt( -9000,      0,  1000));
	cv.SetValue(1, 3, gp_Pnt( -7670,   7670,  6000));
	cv.SetValue(1, 4, gp_Pnt( -3330,  10000, -4130));
	cv.SetValue(2, 0, gp_Pnt(     0, -10000, -5530));
	cv.SetValue(2, 1, gp_Pnt(     0,  -3670,  3000));
	cv.SetValue(2, 2, gp_Pnt(     0,      0, -12000));
	cv.SetValue(2, 3, gp_Pnt(     0,   7670,  1500));
	cv.SetValue(2, 4, gp_Pnt(     0,  10000, -4130));
	cv.SetValue(3, 0, gp_Pnt(  3330, -10000, -6130));
	cv.SetValue(3, 1, gp_Pnt(  7670,  -3670,  6000));
	cv.SetValue(3, 2, gp_Pnt(  9000,      0,  5000));
	cv.SetValue(3, 3, gp_Pnt(  7670,   9000,  7000));
	cv.SetValue(3, 4, gp_Pnt(  3330,  10000, -4130));
	cv.SetValue(4, 0, gp_Pnt( 10000, -10000, -6130));
	cv.SetValue(4, 1, gp_Pnt( 10000,  -4330, -5130));
	cv.SetValue(4, 2, gp_Pnt( 10000,      0, -4130));
	cv.SetValue(4, 3, gp_Pnt( 10000,   4330, -4130));
	cv.SetValue(4, 4, gp_Pnt( 10000,  10000, -8130));
	TColStd_Array1OfReal knots(0, 1);
	knots(0) = 0;
	knots(1) = 1;		
	TColStd_Array1OfInteger mult(0, 1);
	mult(0) = 5;
	mult(1) = 5;	
	Handle(Geom_BSplineSurface) surf = new Geom_BSplineSurface(cv, knots, knots, mult, mult, 4, 4);
#if OCC_VERSION_HEX < 0x60502
	shape = BRepBuilderAPI_MakeFace(surf);
#else
	shape = BRepBuilderAPI_MakeFace(surf, Precision::Confusion());
#endif
}