# /**********************************************************************
# *                                                                     *
# * Copyright (c) 2021 Javier Braña <javier.branagutierrez@gmail.com>  *
# *                                                                     *
# * This program is free software; you can redistribute it and/or modify*
# * it under the terms of the GNU Lesser General Public License (LGPL)  *
# * as published by the Free Software Foundation; either version 2 of   *
# * the License, or (at your option) any later version.                 *
# * for detail see the LICENCE text file.                               *
# *                                                                     *
# * This program 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 Library General Public License for more details.                *
# *                                                                     *
# * You should have received a copy of the GNU Library General Public   *
# * License along with this program; if not, write to the Free Software *
# * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307*
# * USA                                                                 *
# *                                                                     *
# ***********************************************************************

import Arch
import Draft
import FreeCAD
import Mesh
import MeshPart
import Part
import numpy
import os

from xml.etree.ElementTree import Element, SubElement
import xml.etree.ElementTree as ElementTree
import datetime
from xml.dom import minidom

from numpy.matrixlib.defmatrix import matrix

from Utils import PVPlantUtils as utils

if FreeCAD.GuiUp:
    import FreeCADGui
    from PySide import QtCore
    from PySide.QtCore import QT_TRANSLATE_NOOP
    from DraftTools import translate
else:
    def translate(ctxt, txt):
        return txt

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
        return s

try:
    import collada
    COLLADA_AVAILABLE = True
except ImportError:
    COLLADA_AVAILABLE = False

__title__ = "FreeCAD PVSyst importer"
__author__ = "Javier Braña"
#__url__ = "http://www.freecadweb.org"

scale = 0.001  # from millimeters (FreeCAD) to meters (Collada)


def check_collada():
    """Verifica la disponibilidad de pycollada"""
    if not COLLADA_AVAILABLE:
        FreeCAD.Console.PrintError(translate("PVPlant", "pycollada no encontrado, soporte Collada desactivado.") + "\n")
    return COLLADA_AVAILABLE

 # Asegurar que el texto es Unicode válido
def safe_text(text):
    if isinstance(text, bytes):
        return text.decode('utf-8', errors='replace')
    return text

# from ARCH:
def triangulate(shape):
    "triangulates the given face"

    p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
    mesher = p.GetInt("ColladaMesher", 0)
    tessellation = p.GetFloat("ColladaTessellation", 1.0)

    grading = p.GetFloat("ColladaGrading", 0.3)
    segsperedge = p.GetInt("ColladaSegsPerEdge", 1)
    segsperradius = p.GetInt("ColladaSegsPerRadius", 2)
    secondorder = p.GetBool("ColladaSecondOrder", False)
    optimize = p.GetBool("ColladaOptimize", True)
    allowquads = p.GetBool("ColladaAllowQuads", False)

    if mesher == 0:
        return shape.tessellate(tessellation)
    elif mesher == 1:
        return MeshPart.meshFromShape(Shape=shape, MaxLength=tessellation).Topology
    else:
        return MeshPart.meshFromShape(Shape=shape,
                                      GrowthRate=grading,
                                      SegPerEdge=segsperedge,
                                      SegPerRadius=segsperradius,
                                      SecondOrder=secondorder,
                                      Optimize=optimize,
                                      AllowQuad=allowquads
                                      ).Topology


def export(exportList, filename, tessellation=1, colors=None):
    """export(exportList,filename,tessellation=1,colors=None) -- exports FreeCAD contents to a DAE file.
    colors is an optional dictionary of objName:shapeColorTuple or objName:diffuseColorList elements
    to be used in non-GUI mode if you want to be able to export colors. Tessellation is used when breaking
    curved surfaces into triangles."""

    if not checkCollada(): return

    p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Mod/Arch")
    scale = p.GetFloat("ColladaScalingFactor", 1.0)
    scale = scale * 0.001  # from millimeters (FreeCAD) to meters (Collada)
    p = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/View")
    c = p.GetUnsigned("DefaultShapeColor", 4294967295)
    defaultcolor = (float((c >> 24) & 0xFF) / 255.0, float((c >> 16) & 0xFF) / 255.0, float((c >> 8) & 0xFF) / 255.0)
    colmesh = collada.Collada()
    colmesh.assetInfo.upaxis = collada.asset.UP_AXIS.Z_UP

    # authoring info
    cont = collada.asset.Contributor()
    try:
        author = FreeCAD.ActiveDocument.CreatedBy
    except UnicodeEncodeError:
        author = FreeCAD.ActiveDocument.CreatedBy.encode("utf8")
    author = author.replace("<", "")
    author = author.replace(">", "")
    cont.author = author
    ver = FreeCAD.Version()
    appli = "PVPlant for FreeCAD" + ver[0] + "." + ver[1] + " build" + ver[2] + "\n"
    cont.authoring_tool = appli

    colmesh.assetInfo.contributors.append(cont)
    colmesh.assetInfo.unitname = "meter"
    colmesh.assetInfo.unitmeter = 1.0

    defaultmat = None
    objind = 0
    scenenodes = []

    # TODO: cambiar lo de objeclist. Buscar los elementos que se necesitan exportar
    objectlist = Draft.get_group_contents(exportList, walls=True, addgroups=True)
    objectlist = Arch.pruneIncluded(objectlist)
    for obj in objectlist:
        findex = numpy.array([])
        m = None
        if obj.isDerivedFrom("Part::Feature"):
            print("exporting object ", obj.Name, obj.Shape)
            new_shape = obj.Shape.copy()
            new_shape.Placement = obj.getGlobalPlacement()
            m = Mesh.Mesh(triangulate(new_shape))
        elif obj.isDerivedFrom("Mesh::Feature"):
            print("exporting object ", obj.Name, obj.Mesh)
            m = obj.Mesh
        elif obj.isDerivedFrom("App::Part"):
            for child in obj.OutList:
                objectlist.append(child)
            continue
        else:
            continue

        if m:
            Topology = m.Topology
            Facets = m.Facets

            # vertex indices
            vindex = numpy.empty(len(Topology[0]) * 3)
            for i in range(len(Topology[0])):
                v = Topology[0][i]
                vindex[list(range(i * 3, i * 3 + 3))] = (v.x * scale, v.y * scale, v.z * scale)

            # normals
            nindex = numpy.empty(len(Facets) * 3)
            for i in range(len(Facets)):
                n = Facets[i].Normal
                nindex[list(range(i * 3, i * 3 + 3))] = (n.x, n.y, n.z)

            # face indices
            findex = numpy.empty(len(Topology[1]) * 6, numpy.int64)
            for i in range(len(Topology[1])):
                f = Topology[1][i]
                findex[list(range(i * 6, i * 6 + 6))] = (f[0], i, f[1], i, f[2], i)

        print(len(vindex), " vert indices, ", len(nindex), " norm indices, ", len(findex), " face indices.")
        vert_src = collada.source.FloatSource("cubeverts-array" + str(objind), vindex, ('X', 'Y', 'Z'))
        normal_src = collada.source.FloatSource("cubenormals-array" + str(objind), nindex, ('X', 'Y', 'Z'))
        geom = collada.geometry.Geometry(colmesh, "geometry" + str(objind), obj.Name, [vert_src, normal_src])
        input_list = collada.source.InputList()
        input_list.addInput(0, 'VERTEX', "#cubeverts-array" + str(objind))
        input_list.addInput(1, 'NORMAL', "#cubenormals-array" + str(objind))
        matnode = None
        matref = "materialref"
        if hasattr(obj, "Material"):
            if obj.Material:
                if hasattr(obj.Material, "Material"):
                    if "DiffuseColor" in obj.Material.Material:
                        kd = tuple([float(k) for k in obj.Material.Material["DiffuseColor"].strip("()").split(",")])
                        effect = collada.material.Effect("effect_" + obj.Material.Name, [], "phong", diffuse=kd,
                                                         specular=(1, 1, 1))
                        mat = collada.material.Material("mat_" + obj.Material.Name, obj.Material.Name, effect)
                        colmesh.effects.append(effect)
                        colmesh.materials.append(mat)
                        matref = "ref_" + obj.Material.Name
                        matnode = collada.scene.MaterialNode(matref, mat, inputs=[])

        if not matnode:
            if colors:
                if obj.Name in colors:
                    color = colors[obj.Name]
                    if color:
                        if isinstance(color[0], tuple):
                            # this is a diffusecolor. For now, use the first color - #TODO: Support per-face colors
                            color = color[0]
                        # print("found color for obj",obj.Name,":",color)
                        kd = color[:3]
                        effect = collada.material.Effect("effect_" + obj.Name, [], "phong", diffuse=kd,
                                                         specular=(1, 1, 1))
                        mat = collada.material.Material("mat_" + obj.Name, obj.Name, effect)
                        colmesh.effects.append(effect)
                        colmesh.materials.append(mat)
                        matref = "ref_" + obj.Name
                        matnode = collada.scene.MaterialNode(matref, mat, inputs=[])
            elif FreeCAD.GuiUp:
                if hasattr(obj.ViewObject, "ShapeColor"):
                    kd = obj.ViewObject.ShapeColor[:3]
                    effect = collada.material.Effect("effect_" + obj.Name, [], "phong", diffuse=kd, specular=(1, 1, 1))
                    mat = collada.material.Material("mat_" + obj.Name, obj.Name, effect)
                    colmesh.effects.append(effect)
                    colmesh.materials.append(mat)
                    matref = "ref_" + obj.Name
                    matnode = collada.scene.MaterialNode(matref, mat, inputs=[])

        if not matnode:
            if not defaultmat:
                effect = collada.material.Effect("effect_default", [], "phong", diffuse=defaultcolor,
                                                 specular=(1, 1, 1))
                defaultmat = collada.material.Material("mat_default", "default_material", effect)
                colmesh.effects.append(effect)
                colmesh.materials.append(defaultmat)
            matnode = collada.scene.MaterialNode(matref, defaultmat, inputs=[])

        triset = geom.createTriangleSet(findex, input_list, matref)
        geom.primitives.append(triset)
        colmesh.geometries.append(geom)
        geomnode = collada.scene.GeometryNode(geom, [matnode])
        node = collada.scene.Node("node" + str(objind), children=[geomnode])
        scenenodes.append(node)
        objind += 1

    myscene = collada.scene.Scene("PVScene", scenenodes)
    colmesh.scenes.append(myscene)
    colmesh.scene = myscene
    colmesh.write(filename)

    FreeCAD.Console.PrintMessage(translate("Arch", "file %s successfully created.") % filename)


def exportToPVC(path, exportTerrain=False):
    filename = f"{path}.pvc"

    # 1. Validación inicial de objetos esenciales
    site = None
    for obj in FreeCAD.ActiveDocument.Objects:
        if obj.Name.startswith("Site") and hasattr(obj, 'Terrain'):
            site = obj
            break

    if not site:
        FreeCAD.Console.PrintError("No se encontró objeto 'Site' válido\n")
        return False

    # 2. Configuración de metadatos y autor
    generated_on = str(datetime.datetime.now())

    try:
        author = FreeCAD.ActiveDocument.CreatedBy
    except (AttributeError, UnicodeEncodeError):
        author = "Unknown"

    author = author.replace("<", "").replace(">", "")
    ver = FreeCAD.Version()
    appli = f"PVPlant for FreeCAD {ver[0]}.{ver[1]} build{ver[2]}"

    # 3. Creación estructura XML base
    root = Element('COLLADA')
    root.set('xmlns', 'http://www.collada.org/2005/11/COLLADASchema')
    root.set('version', '1.4.1')

    # 4. Sección <asset>
    asset = SubElement(root, 'asset')
    contrib = SubElement(asset, 'contributor')
    SubElement(contrib, 'author').text = safe_text(author)
    SubElement(contrib, 'authoring_tool').text = safe_text(appli)
    SubElement(asset, 'created').text = generated_on
    SubElement(asset, 'modified').text = generated_on
    SubElement(asset, 'title').text = safe_text(FreeCAD.ActiveDocument.Name)
    unit = SubElement(asset, 'unit')
    unit.set('name', 'meter')
    unit.set('meter', '1')

    # 5. Materiales y efectos
    materials = ["Frames", "Tree_trunk", "Tree_crown", "Topography_mesh"]

    # Library materials
    lib_materials = SubElement(root, 'library_materials')
    for i, name in enumerate(materials):
        mat = SubElement(lib_materials, 'material')
        mat.set('id', f'Material{i}')
        mat.set('name', name)
        SubElement(mat, 'instance_effect').set('url', f'#Material{i}-fx')

    # Library effects
    lib_effects = SubElement(root, 'library_effects')
    for i, _ in enumerate(materials):
        effect = SubElement(lib_effects, 'effect')
        effect.set('id', f'Material{i}-fx')
        effect.set('name', f'Material{i}')
        profile = SubElement(effect, 'profile_COMMON')
        technique = SubElement(profile, 'technique')
        technique.set('sid', 'standard')
        lambert = SubElement(technique, 'lambert')

        # Componentes del material
        color = SubElement(SubElement(lambert, 'emission'), 'color')
        color.set('sid', 'emission')
        color.text = '0.000000 0.000000 0.000000 1.000000'
        color = SubElement(SubElement(lambert, 'ambient'), 'color')
        color.set('sid', 'ambient')
        color.text = '0.200000 0.200000 0.200000 1.000000'
        color = SubElement(SubElement(lambert, 'diffuse'), 'color')
        color.set('sid', 'diffuse')
        color.text = '0.250000 0.500000 0.000000 1.000000'
        transparent = SubElement(lambert, 'transparent')
        transparent.set('opaque', 'RGB_ZERO')
        color = SubElement(transparent, 'color')
        color.set('sid', 'transparent')
        color.text = '0.000000 0.000000 0.000000 1.000000'
        value = SubElement(SubElement(lambert, 'transparency'), 'float')
        value.set('sid', 'transparency')
        value.text = '0.000000'

    # 6. Geometrías
    lib_geometries = SubElement(root, 'library_geometries')

    # 7. Escena visual
    lib_visual = SubElement(root, 'library_visual_scenes')
    visual_scene = SubElement(lib_visual, 'visual_scene')
    visual_scene.set('id', 'Scene')  # cambiar a visual_scene_0
    visual_scene.set('name', 'Scene') # cambiar a Default visual scene

    scene_node = SubElement(visual_scene, 'node')
    scene_node.set('id', 'node_0_id')
    scene_node.set('name', 'node_0_name')
    scene_node.set('sid', 'node_0_sid')

    scene_matrix = SubElement(scene_node, 'matrix')
    scene_matrix.set('sid', 'matrix_0')
    scene_matrix.text = '1.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -1.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 0.000000 0.000000 1.000000'

    root_node = SubElement(scene_node, 'node')
    root_node.set('id', 'node_1_id')
    root_node.set('name', 'node_1_name')
    root_node.set('sid', 'node_1_sid')

    # 8. Función para procesar geometrías
    def create_geometry(name, vindex, findex, material_id, objind=0, frame_data=None, isTracker = False, axis_line=None):
        """Crea elementos COLLADA para una geometría"""
        # Source (vertices)
        source_mesh = SubElement(geom, 'mesh')
        source = SubElement(source_mesh, 'source')
        source.set('id', f'{name}-mesh_source')
        float_array = SubElement(source, 'float_array')
        float_array.set('id', f'{name}-float_array')
        float_array.set('count', str(len(vindex)))
        float_array.text = ' '.join(f'{v:.6f}' for v in vindex)

        technique = SubElement(source, 'technique_common')
        accessor = SubElement(technique, 'accessor')
        accessor.set('count', str(len(vindex)))
        accessor.set('source', f'#{name}-float_array')
        accessor.set('stride', '3')
        for ax in ['X', 'Y', 'Z']:
            param = SubElement(accessor, 'param')
            param.set('name', ax)
            param.set('type', 'float')

        # Vertices
        vertices = SubElement(source_mesh, 'vertices')
        vertices.set('id', f'{name}-vertices_source')
        vertices = SubElement(vertices, 'input')
        vertices.set('semantic', 'POSITION')
        vertices.set('source', f'#{name}-mesh_source')

        # Triangles
        triangles = SubElement(source_mesh, 'triangles')
        triangles.set('count', '0')
        triangles.set('material', f'Material{material_id}')
        triangles_input = SubElement(triangles, 'input')
        triangles_input.set('offset', '0')
        triangles_input.set('semantic', 'VERTEX')
        triangles_input.set('source', f'#{name}-vertices_source')

        p = SubElement(triangles, 'p')
        p.text = ' '.join(map(str, findex))

        # Parámetros especiales para estructuras

        frame_params = SubElement(source_mesh, 'tracker_parameters')
        if frame_data:
            for key, val in frame_data.items():
                elem = SubElement(frame_params, key)
                elem.text = str(val)

        if isTracker:
            axis_parameter = SubElement(frame_params, 'axis_vertices')
            if axis_line:
                for idx, vert in enumerate(axis_line):
                    array = SubElement(axis_parameter, 'float_array')
                    array.set('id', f'{name}-axis_float_array{idx}')
                    array.set('count', '3')
                    array.text = ' '.join(f'{v:.6f}' for v in vert)

    # 9. Procesar estructuras (frames/trackers)
    center = FreeCAD.Vector()
    if site.Terrain:
        center = site.Terrain.Mesh.BoundBox.Center

    objind = 0
    for frame_type in site.Frames:
        is_tracker = "tracker" in frame_type.Proxy.Type.lower()

        modules = frame_type.Shape.SubShapes[0].SubShapes[0]
        pts = []
        for i in range(4):
            pts.append(modules.BoundBox.getPoint(i))

        new_shape = Part.Face(Part.makePolygon(pts))
        mesh = Mesh.Mesh(triangulate(new_shape))
        axis = Part.makeLine(FreeCAD.Vector(modules.BoundBox.XMin, 0, modules.BoundBox.ZMax),
                             FreeCAD.Vector(modules.BoundBox.XMax, 0, modules.BoundBox.ZMax))

        for obj in FreeCAD.ActiveDocument.Objects:
            if hasattr(obj, "Setup") and obj.Setup == frame_type:
                # Procesar geometría
                mesh.Placement = obj.getGlobalPlacement()
                axis.Placement = obj.getGlobalPlacement()

                # Transformar vértices
                vindex = []
                for point in mesh.Points:
                    adjusted = (point.Vector - center) * scale
                    vindex.extend([
                        -adjusted.x,
                        adjusted.z,
                        adjusted.y
                    ])

                # Índices de caras
                findex = []
                for facet in mesh.Facets:
                    findex.extend(facet.PointIndices)

                # AXIS
                # TODO: revisar si es así:
                vaxis = []
                for vert in axis.Vertexes:
                    adjusted = (vert.Point - center) * scale
                    vaxis.append([
                        -adjusted.x,
                        adjusted.z,
                        adjusted.y
                    ])

                # Crear geometría COLLADA
                geom = SubElement(lib_geometries, 'geometry')
                geom.set('id', f'Frame_{objind}')

                # Parámetros específicos de estructura
                frame_data = {
                    'module_width': obj.Setup.ModuleWidth.Value,
                    'module_height': obj.Setup.ModuleHeight.Value,
                    'module_x_spacing': obj.Setup.ModuleColGap.Value,
                    'module_y_spacing': obj.Setup.ModuleRowGap.Value,
                    'module_name': 'Generic'
                }

                if is_tracker:
                    frame_data.update({
                        'tracker_type': 'single_axis_trackers',
                        'min_phi': obj.Setup.MinPhi.Value,
                        'max_phi': obj.Setup.MaxPhi.Value,
                        'min_theta': 0,
                        'max_theta': 0
                    })

                create_geometry(
                    name=f'Frame_{objind}',
                    vindex=vindex,
                    findex=findex,
                    material_id=0,
                    objind=objind,
                    frame_data=frame_data,
                    isTracker = is_tracker,
                    axis_line=vaxis
                )

                # Instancia en escena
                instance = SubElement(root_node, 'instance_geometry')
                instance.set('url', f'#Frame_{objind}')

                bind_material = SubElement(instance, 'bind_material')
                technique_common = SubElement(bind_material, 'technique_common')
                instance_material = SubElement(technique_common, 'instance_material')
                instance_material.set('symbol', 'Material0')
                instance_material.set('target', '#Material0')

                objind += 1

    # 10. Procesar terreno si está habilitado
    if exportTerrain and site.Terrain:
        mesh = site.Terrain.Mesh
        vindex = []
        for point in mesh.Points:
            point = point.Vector
            vindex.extend([
                -point.x * SCALE,
                point.z * SCALE,
                point.y * SCALE
            ])

        findex = []
        for facet in mesh.Facets:
            findex.extend(facet.PointIndices)

        geom = SubElement(lib_geometries, 'geometry')
        geom.set('id', 'Terrain')
        create_geometry('Terrain', vindex, findex, material_id=3)

        instance = SubElement(root_node, 'instance_geometry')
        instance.set('url', '#Terrain')

    # 11. Escena principal
    scene = SubElement(root, 'scene')
    SubElement(scene, 'instance_visual_scene').set('url', '#Scene')

    # 12. Exportar a archivo
    xml_str = minidom.parseString(
        ElementTree.tostring(root, encoding='utf-8')
    ).toprettyxml(indent="  ")

    with open(filename, 'w', encoding='utf-8') as f:
        f.write(xml_str)

    FreeCAD.Console.PrintMessage(f"Archivo PVC generado: {filename}\n")
    return True

def exportToPVC_old(path, exportTerrain = False):
    filename = f"{path}.pvc"

    from xml.etree.ElementTree import Element, SubElement
    import datetime

    generated_on = str(datetime.datetime.now())

    site = None
    tmp = FreeCAD.ActiveDocument.getObjectsByLabel('Site')
    for obj in tmp:
        if obj.Name.startswith("Site"):
            site = obj
            break
    terrain = None
    center = None
    if not(site.Terrain is None):
        terrain = site.Terrain.Mesh
        center = terrain.BoundBox.Center
    else:
        center = FreeCAD.Vector()

    try:
        author = FreeCAD.ActiveDocument.CreatedBy
    except UnicodeEncodeError:
        author = FreeCAD.ActiveDocument.CreatedBy.encode("utf8")

    author = author.replace("<", "")
    author = author.replace(">", "")
    ver = FreeCAD.Version()
    appli = "PVPlant for FreeCAD" + ver[0] + "." + ver[1] + " build" + ver[2] + "\n"

    # xml: Configure one attribute with set()
    root = Element('COLLADA')
    root.set('xmlns:xsd', 'http://www.w3.org/2001/XMLSchema')
    root.set('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance')
    root.set('version', '1.4.1')
    root.set('xmlns', 'http://www.collada.org/2005/11/COLLADASchema')
    #root.append(Comment('Generated by ElementTree_csv_to_xml.py for PyMOTW'))

    # xml: 1. Asset:
    asset = SubElement(root, 'asset')

    asset_contributor = SubElement(asset, 'contributor')
    asset_contributor_autor = SubElement(asset_contributor, 'author')
    asset_contributor_autor.text = author
    asset_contributor_authoring_tool = SubElement(asset_contributor, 'authoring_tool')
    asset_contributor_authoring_tool.text = appli
    asset_contributor_comments = SubElement(asset_contributor, 'comments')
    asset_keywords = SubElement(asset, 'keywords')
    asset_revision = SubElement(asset, 'revision')
    asset_subject = SubElement(asset, 'subject')
    asset_tittle = SubElement(asset, 'title')
    asset_tittle.text = FreeCAD.ActiveDocument.Name
    asset_unit = SubElement(asset, 'unit')
    asset_unit.set('meter', '0.001')
    asset_unit.set('name', 'millimeter')

    # xml: 2. library_materials:
    library_materials = SubElement(root, 'library_materials')
    buf = ['Frames', 'Tree_trunk', 'Tree_crown', 'Topography_mesh']

    for i in range(0, len(buf)):
        material = SubElement(library_materials, 'material')
        material.set('id', 'Material{0}'.format(i))
        material.set('name', buf[i])
        material_effect = SubElement(material, 'instance_effect')
        material_effect.set('url', '#Material{0}-fx'.format(i))

    # xml: 3. library_effects:
    library_effects = SubElement(root, 'library_effects')
    buf = ['0.250000 0.500000 0.000000 1.000000',
           '0.500000 0.375000 0.250000 1.000000',
           '0.250000 1.000000 0.000000 1.000000',
           '0.250000 1.000000 0.000000 1.000000']

    for i in range(0, len(buf)):
        effect = SubElement(library_effects, 'effect')
        effect.set('id', 'Material{0}-fx'.format(i))
        effect.set('name', 'Material{0}'.format(i))
        profile_COMMON = SubElement(effect, 'profile_COMMON')
        library_effects_effect_technique = SubElement(profile_COMMON, 'technique')
        library_effects_effect_technique.set('sid', 'standard')
        library_effects_effect_technique_lambert = SubElement(library_effects_effect_technique, 'lambert')
        library_effects_effect_technique_lambert_emission = SubElement(library_effects_effect_technique_lambert,
                                                                       'emission')
        library_effects_effect_technique_lambert_emission_color = SubElement(
            library_effects_effect_technique_lambert_emission, 'color')
        library_effects_effect_technique_lambert_emission_color.set('sid', 'emission')
        library_effects_effect_technique_lambert_emission_color.text = '0.000000 0.000000 0.000000 1.000000'
        ambient = SubElement(library_effects_effect_technique_lambert, 'ambient')
        ambient_color = SubElement(ambient, 'color')
        ambient_color.set('sid', 'ambient')
        ambient_color.text = '0.200000 0.200000 0.200000 1.000000'
        diffuse = SubElement(library_effects_effect_technique_lambert, 'diffuse')
        diffuse_color = SubElement(diffuse, 'color')
        diffuse_color.set('sid', 'diffuse')
        diffuse_color.text = buf[i]
        transparent = SubElement(library_effects_effect_technique_lambert, 'transparent')
        transparent.set('opaque', 'RGB_ZERO')
        transparent_color = SubElement(transparent, 'color')
        transparent_color.set('sid', 'transparent')
        transparent_color.text = '0.000000 0.000000 0.000000 1.000000'
        transparency = SubElement(library_effects_effect_technique_lambert, 'transparency')
        transparency_value = SubElement(transparency, 'float')
        transparency_value.set('sid', 'transparency')
        transparency_value.text = '0'

    # xml: 4. library_geometries:
    library_geometries = SubElement(root, 'library_geometries')
    def add_geometry(objtype, vindex, findex, objind = 0, centers = None):
        isFrame = False
        if objtype == 0:
            geometryName = 'Frame'
            referenceSTR = 'frame'
            isFrame = True
        elif objtype == 1:
            geometryName = 'ShadowMesh'  ## --> ???
            referenceSTR = 'ShadowMesh'  ## --> ???
        elif objtype == 2:
            geometryName = 'TerrainMesh'
            referenceSTR = 'TerrainMesh'

        geometry = SubElement(library_geometries, 'geometry')
        geometry.set('id', geometryName + '{0}'.format(objind))
        mesh = SubElement(geometry, 'mesh')

        source = SubElement(mesh, 'source')
        source.set('id', referenceSTR + '{0}MeshSource'.format(objind))
        float_array = SubElement(source, 'float_array')
        float_array.set('id', referenceSTR + '{0}FloatArray'.format(objind))
        float_array.set('count', '{0}'.format(len(vindex)))
        float_array.text = ""  # vindex
        for ver in vindex:
            if len(float_array.text) > 0:
                float_array.text += ' '
            float_array.text += '{0:.6f}'.format(ver)

        technique_common = SubElement(source, 'technique_common')
        accessor = SubElement(technique_common, 'accessor')
        accessor.set('count', '{0}'.format(len(vindex)))
        accessor.set('source', '#' + referenceSTR + '{0}FloatArray'.format(objind))
        accessor.set('stride', '3')
        param = SubElement(accessor, 'param')
        param.set('name', 'X')
        param.set('type', 'float')
        param = SubElement(accessor, 'param')
        param.set('name', 'Y')
        param.set('type', 'float')
        param = SubElement(accessor, 'param')
        param.set('name', 'Z')
        param.set('type', 'float')

        vertices = SubElement(mesh, 'vertices')
        vertices.set('id', referenceSTR + '{0}VerticesSource'.format(objind))
        input = SubElement(vertices, "input")
        input.set('semantic', 'POSITION')
        input.set('source', '#' + referenceSTR + '{0}MeshSource'.format(objind))

        triangles = SubElement(mesh, 'triangles')
        triangles.set('count', '0')
        triangles.set('material', 'Material0')
        input = SubElement(triangles, "input")
        input.set('offset', '0')
        input.set('semantic', 'VERTEX')
        input.set('source', '#' + referenceSTR + '{0}VerticesSource'.format(objind))
        p = SubElement(triangles, "p")
        p.text = ''
        for f in findex:
            if len(p.text) > 0:
                p.text += ' '
            p.text += '{0}'.format(f)

        if isFrame:
            frame = SubElement(mesh, 'tracker_parameters' if isTracker else 'frame_parameters')
            module_width = SubElement(frame, "module_width")
            module_width.text = '{0}'.format(int(obj.Setup.ModuleWidth.Value))
            module_height = SubElement(frame, "module_height")
            module_height.text = '{0}'.format(int(obj.Setup.ModuleHeight.Value))
            module_x_spacing = SubElement(frame, "module_x_spacing")
            module_x_spacing.text = '{0}'.format(int(obj.Setup.ModuleColGap.Value))
            module_y_spacing = SubElement(frame, "module_y_spacing")
            module_y_spacing.text = '{0}'.format(int(obj.Setup.ModuleRowGap.Value))
            module_manufacturer = SubElement(frame, "module_manufacturer")
            module_manufacturer.text = 'generic'
            module_name = SubElement(frame, "module_name")
            module_name.text = 'generic'
            if isTracker:
                tracker_type = SubElement(frame, 'tracker_type')
                tracker_type.text = 'single_axis_trackers'
                axis = SubElement(frame, 'axis_vertices')
                for ind in range(0, len(centers)):
                    array = SubElement(axis, 'float_array')
                    array.set('id', 'tracker{0}AxisFloatArray1'.format(ind))
                    array.set('count', '3')
                    array.text = '{0:.6f} {1:.6f} {2:.6f}'.format(centers[ind].x, centers[ind].y, centers[ind].z)

                min_phi = SubElement(frame, 'min_phi')
                min_phi.text = '{0}'.format(int(obj.Setup.MinPhi.Value))
                max_phi = SubElement(frame, 'max_phi')
                max_phi.text = '{0}'.format(int(obj.Setup.MaxPhi.Value))
                min_theta = SubElement(frame, 'min_theta')
                min_theta.text = '{0}'.format(0)
                max_theta = SubElement(frame, 'max_theta')
                max_theta.text = '{0}'.format(0)

        # xml: 5. library_visual_scenes:
        instance_geometry = SubElement(node, 'instance_geometry')
        instance_geometry.set('url', geometryName + '{0}'.format(objind))

        bind_material = SubElement(instance_geometry, 'bind_material')
        technique_common = SubElement(bind_material, 'technique_common')
        instance_material = SubElement(technique_common, 'instance_material')
        instance_material.set('symbol', 'Material0')
        instance_material.set('target', '#Material0')
        instance_material = SubElement(technique_common, 'instance_material')
        instance_material.set('symbol', 'Material1')
        instance_material.set('target', '#Material1')
        instance_material = SubElement(technique_common, 'instance_material')
        instance_material.set('symbol', 'Material2')
        instance_material.set('target', '#Material2')

    # xml: 5. library_visual_scenes:
    library_visual_scenes = SubElement(root, 'library_visual_scenes')
    visual_scene = SubElement(library_visual_scenes, 'visual_scene')
    visual_scene.set('id', '')
    visual_scene.set('name', '')

    node = SubElement(visual_scene, 'node')
    node.set('id', 'Fbx_Root')
    node.set('name', 'Fbx_Root')
    node.set('sid', 'Fbx_Root')
    matrix = SubElement(node, 'matrix')
    matrix.set('sid', 'matrix')
    matrix.text = '1.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -1.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 0.000000 0.000000 1.000000'
    node = SubElement(node, 'node')
    node.set('id', 'PVcase52')
    node.set('name', 'PVcase52')
    node.set('sid', 'PVcase52')
    matrix = SubElement(node, 'matrix')
    matrix.set('sid', 'matrix')
    matrix.text = '1.000000 0.000000 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 0.000000 1.000000 0.000000 0.000000 0.000000 0.000000 1.000000'

    extra = SubElement(visual_scene, 'extra')
    technique = SubElement(extra, 'technique')
    technique.set('profile', 'MAX3D')
    frame_rate = SubElement(technique, 'frame_rate')
    frame_rate.text = '30.000000'
    technique = SubElement(extra, 'technique')
    technique.set('profile', 'FCOLLADA')
    start_time = SubElement(technique, 'start_time')
    start_time.text = '0.000000'
    end_time = SubElement(technique, 'end_time')
    end_time.text = '1.000000'

    # xml: 6. scene:
    '''scene = SubElement(root, 'scene')
    instance = SubElement(scene, 'instance_visual_scene')
    instance.set('url', '#')'''

    # CASO 1 - FRAMES:
    frameType = site.Frames
    objind = 0

    # TODO: revisar
    for typ in frameType:
        isTracker = "tracker" in typ.Proxy.Type.lower()
        #isTracker = False

        objectlist = utils.findObjects("Tracker")
        for obj in objectlist:
            if obj.Setup == typ:
                findex = numpy.array([])

                modules = obj.Setup.Shape.SubShapes[0].SubShapes[0]
                pts = []
                for i in range(4):
                    pts.append(modules.BoundBox.getPoint(i))

                # temp -----
                if obj.Tilt.Value != 0:
                    zz = int(pts[0].z) - (obj.Setup.MainBeamHeight.Value / 2 + obj.Setup.BeamHeight.Value)
                    for p in pts:
                        p.z -= zz
                    new_shape = Part.Face(Part.makePolygon(pts))
                    new_shape.Placement.Rotation.setEulerAngles("XYZ", obj.Tilt.Value, 0, 0)
                    pts = []
                    for ver in new_shape.Vertexes:
                        p = ver.Point
                        p.z += zz
                        pts.append(p)
                # end temp -----

                new_shape = Part.Face(Part.makePolygon(pts))
                new_shape.Placement = obj.Placement.copy()
                m = Mesh.Mesh(triangulate(new_shape))
                centers = []

                if isTracker:
                    minLengths = []
                    for ed in new_shape.Edges:
                        minLengths.append(ed.Length)
                    minLength = min(minLengths)
                    for ed in new_shape.Edges:
                        if ed.Length == minLength:
                            centers.append(ed.CenterOfMass)
                if m:
                    Topology = m.Topology

                    # 1. vertex indices
                    vindex = numpy.empty(len(Topology[0]) * 3)
                    for i in range(len(Topology[0])):
                        v = Topology[0][i]
                        vindex[list(range(i * 3, i * 3 + 3))] = (-(v.x - center.x) * scale, (v.z - center.z) * scale,
                                                                 (v.y - center.y) * scale)
                    # 2. face indices
                    findex = numpy.empty(len(Topology[1]) * 3, numpy.int64)
                    for i in range(len(Topology[1])):
                        f = Topology[1][i]
                        findex[list(range(i * 3, i * 3 + 3))] = (f[0], f[1], f[2])

                    add_geometry(0, vindex, findex, objind, centers if isTracker else None)
                    objind += 1

    # CASE 2: Shadow objects
    #objectlist = FreeCAD.ActiveDocument.findObjects(Label = "Tree")  # TODO: Cambiar label por name
    objectlist=[]
    for obj in FreeCAD.ActiveDocument.Objects:
        if obj.Name.startswith("Tracker"):
            continue
        else:
            objectlist.append(obj)
    objind = 0

    for obj in objectlist:
        findex = numpy.array([])
        m = None
        if obj.isDerivedFrom("Part::Feature"):
            new_shape = obj.Shape.copy()
            new_shape.Placement = obj.getGlobalPlacement()
            m = Mesh.Mesh(triangulate(new_shape))
        elif obj.isDerivedFrom("Mesh::Feature"):
            m = obj.Mesh
        elif obj.isDerivedFrom("App::Part"):
            for child in obj.OutList:
                objectlist.append(child)
            continue
        else:
            continue

        if m:
            Topology = m.Topology
            # vertex indices
            vindex = numpy.empty(len(Topology[0]) * 3)
            for i in range(len(Topology[0])):
                v = Topology[0][i]
                vindex[list(range(i * 3, i * 3 + 3))] = (-(v.x - center.x) * scale, (v.z - center.z) * scale,
                                                         (v.y - center.y) * scale)

            # face indices
            findex = numpy.empty(len(Topology[1]) * 3, numpy.int64)
            for i in range(len(Topology[1])):
                f = Topology[1][i]
                findex[list(range(i * 3, i * 3 + 3))] = (f[0], f[1], f[2])

            add_geometry(1, vindex, findex, objind)
            objind += 1


    # CASE 3: Terrain
    # TODO: ver si se puede partir en varias mesh para que trabaje más rápido
    if exportTerrain:
        m = terrain
        if m:
            Topology = m.Topology
            # Facets = m.Facets

            # vertex indices
            vindex = numpy.empty(len(Topology[0]) * 3)
            for i in range(len(Topology[0])):
                v = Topology[0][i]
                vindex[list(range(i * 3, i * 3 + 3))] = (-v.x * scale, v.z * scale, v.y * scale)

            # face indices
            findex = numpy.empty(len(Topology[1]) * 3, numpy.int64)
            for i in range(len(Topology[1])):
                f = Topology[1][i]
                findex[list(range(i * 3, i * 3 + 3))] = (f[0], f[1], f[2])

            add_geometry(2, vindex, findex)

        # xml: 5. library_visual_scenes: ¿¿¿¿¿???????
        '''
        instance_geometry = SubElement(node, 'instance_geometry')
        instance_geometry.set('url', 'TerrainMesh{0}'.format(0))

        bind_material = SubElement(instance_geometry, 'bind_material')
        technique_common = SubElement(bind_material, 'technique_common')
        instance_material = SubElement(technique_common, 'instance_material')
        instance_material.set('symbol', 'Material0')
        instance_material.set('target', '#Material0')
        instance_material = SubElement(technique_common, 'instance_material')
        instance_material.set('symbol', 'Material1')
        instance_material.set('target', '#Material1')
        instance_material = SubElement(technique_common, 'instance_material')
        instance_material.set('symbol', 'Material2')
        instance_material.set('target', '#Material2')
        '''

    extra = SubElement(node, 'extra')
    technique = SubElement(extra, 'technique')
    technique.set('profile', 'FCOLLADA')
    visibility = SubElement(technique, 'visibility')
    visibility.text = '1.000000'


    # save the file:
    st = prettify(root)
    #print(st)
    f = open(filename, "w")
    f.write(st)
    f.close()
    FreeCAD.Console.PrintMessage("Se ha generado correctamente el archivo PVC: ", filename)
    return True

def prettify(elem):
    """ Return a pretty-printed XML string for the Element. """

    from xml.etree import ElementTree
    from xml.dom import minidom

    rough_string = ElementTree.tostring(elem, 'utf-8')
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent="  ")

def exportToH2P(path):  # sólo válido para mesas
    filename = path + ".h2p"
    f2 = '{:.2f}'
    f3 = '{:.3f}'

    st = 'START\n'
    # TODO: hacer un bucle para cada tipo-tamaño de estructura.
    #       posible solucción: un primer bucle para identificar los tipos-tamaños de estructura
    #FreeCAD.ActiveDocument.findObjects
    #FreeCAD.ActiveDocument.Objects

    objects = FreeCAD.ActiveDocument.findObjects(Name="Tracker")
    grouptype = []
    #for obj in objects:
    grouptype.append(objects[0])

    for typ in grouptype:
        st += 'TABLE\n' \
              '10\n'
        st += f3.format(typ.Width.Value) + ',' + f3.format(typ.Length.Value) + ','  + \
              f3.format(0)  + ',' + f3.format(0)  + ',' + f3.format(0)  + ',' + f3.format(0) + "\n"
              #'#{ f3 %pvsyst.ilb.to_mm },#{f3 %pvsyst.irb.to_mm},#{f3 %pvsyst.itb.to_mm},' \
              #'#{f3 %pvsyst.ibb.to_mm}\n'
        st += '20\n'
        st += str(int(typ.ModulesCols.Value)) + ',' + str(int(typ.ModulesRows.Value)) + ',' + \
              str(typ.ModuleColGap.Value) + ',' + str(typ.ModuleRowGap.Value) + ',' + '30\n'
        st += '30\n'
        st += '1,' + f3.format(typ.ModuleWidth.Value) + ',' + f3.format(typ.ModuleHeight.Value) + ',' + \
              f3.format(typ.ModuleThick.Value) + ',' + f2.format(450) + '\n' #f2.format(typ.ModulePower.Value) + '\n'

        # cornerdown = find_component_sizes(group.cdef)[1]
        # pvorigin = Geom::Point3d.new(cornerdown.x, cornerdown.y, 0)
        # group.instances.each{ | ins | str += pvsyst_insert(ins, pvorigin)}

        for obj in objects:
            if obj.CloneOf == typ:
                st += H2PInsert(obj)

    ## TODO: Bucle para buscar objetos que den sombra y el terreno. Todos llaman a H2PMesh
    mesh = FreeCAD.ActiveDocument.getObjectsByLabel('Surface')[0].Mesh
    st += H2PMesh(mesh, False)
    st += "END\n"

    # save the file:
    f = open(filename, "w")
    f.write(st)
    f.close()
    FreeCAD.Console.PrintMessage("Se ha generado el archivo PVC: ", filename)
    return True

def H2PInsert(obj):
    f3 = '{:.3f}'
    f2 = '{:.2f}'
    scale = 0.001  ## ver como se puede hacer para que sea general. Pasar de mm a m

    st = 'INSERT\n' \
         '10\n'
    st += f3.format(obj.Placement.Base.x * scale) + ',' + f3.format(obj.Placement.Base.y * scale) + ',' + \
          f3.format((obj.Placement.Base.z + obj.PoleLength.Value - obj.RammingDeep.Value + 1000) * scale) + '\n'
    st += '50\n'
    st += f2.format(-obj.Placement.Rotation.toEuler()[0]) + '\n'
    st += '55\n'
    st += f2.format(obj.Placement.Rotation.toEuler()[1]) + '\n'
    st += '56\n'
    st += f2.format(obj.Placement.Rotation.toEuler()[2]) + '\n'

    return st

def H2PMesh(mesh, typ):
    scale = 0.001  ## ver como se puede hacer para que sea general. Pasar de mm a m

    f3 = '{:.3f}'
    st = ''
    if typ:
        st = 'ShadowObject\nFence\n'
    else:
        st = 'DGM\n'

    for face in mesh.Facets:
        p1 = face.Points[0]
        p2 = face.Points[1]
        p3 = face.Points[2]

        st += f3.format(p1[0] * scale) + "," + f3.format(p1[1] * scale) + "," + f3.format(p1[2] * scale) + ";"
        st += f3.format(p2[0] * scale) + "," + f3.format(p2[1] * scale) + "," + f3.format(p2[2] * scale) + ";"
        st += f3.format(p3[0] * scale) + "," + f3.format(p3[1] * scale) + "," + f3.format(p3[2] * scale) + "\n"

    return st

class PVSystTaskPanel:

    def __init__(self):
        self.form = FreeCADGui.PySideUic.loadUi(os.path.dirname(__file__) + "/exportPVSyst.ui")
        self.form = self.form

    def show(self):
        # self.form.setWindowModality(Qt.WindowModal)
        self.form.show()

    def accept(self):
        import datetime
        x = datetime.datetime.now()
        date = x.strftime("%Y%m%d%H%M%S")
        overwrite = True

        path = os.path.join(os.path.dirname(FreeCAD.ActiveDocument.FileName), "outputs", "PVSyst")
        if not os.path.exists(path):
            os.makedirs(path)

        name = FreeCAD.ActiveDocument.Label
        #if not overwrite:
        name = date + "-" + name
        filename = os.path.join(path, name)


        if self.form.cbPVC.isChecked():
            exportToPVC(filename, self.form.cbTerrain.isChecked())

        if self.form.cbH2P.isChecked():
            exportToH2P(filename)

        FreeCADGui.Control.closeDialog()
        return True

    def reject(self):
        FreeCADGui.Control.closeDialog()
        return True

'''class _CommandExportToPVSyst:
    "Export to PVSyst"

    def GetResources(self):
        return {'Pixmap': str(os.path.join(DirIcons, "PVsyst.png")),
                'Accel': "E, P",
                'MenuText': QT_TRANSLATE_NOOP("Outputs", "Export to PVSyst"),
                'ToolTip': QT_TRANSLATE_NOOP("Outputs", "Exportar a PVSyst")}

    def Activated(self):
        taskd = _PVSystTaskPanel()
        # taskd.show()
        FreeCADGui.Control.showDialog(taskd)

    def IsActive(self):
        if FreeCAD.ActiveDocument:
            return True
        else:
            return False

if FreeCAD.GuiUp:
    FreeCADGui.addCommand('ExportToPVSyst', _CommandExportToPVSyst())'''