# -*- coding: utf-8 -*-
"""Digimax SKP to Revit: one loadable family per material.

Reads a families pack (*.dgx-families.json) written by
https://digimax-skp2revit.laurent-7ad.workers.dev and, for every material:
  1. makes a family from the Generic Model template,
  2. adds the mesh as a DirectShape with a Revit material of the same name and colour,
  3. saves it as <name>.rfa next to the pack,
  4. loads it into the open project and places it where it was in SketchUp.

Runs in pyRevit (IronPython 2.7 or CPython) and RevitPythonShell.
Written for Revit 2022+; older versions are tried but not promised.
"""
from __future__ import print_function

__title__ = 'Families\nfrom pack'
__author__ = 'Digimax Ltd'

import io
import json
import os
import re

import clr
clr.AddReference('RevitAPI')
clr.AddReference('RevitAPIUI')
clr.AddReference('System')
from System import Byte
from System.Collections.Generic import List
from Autodesk.Revit.DB import (
    BuiltInCategory, Color, DirectShape, ElementId, ElementTransformUtils, FamilySymbol,
    FilteredElementCollector, IFamilyLoadOptions, Level, Material, SaveAsOptions,
    TessellatedFace, TessellatedShapeBuilder, TessellatedShapeBuilderFallback,
    TessellatedShapeBuilderTarget, Transaction, XYZ,
)
from Autodesk.Revit.DB.Structure import StructuralType

try:  # pyRevit
    uiapp = __revit__  # noqa: F821
except NameError:  # RevitPythonShell exposes the same name; fail clearly elsewhere
    raise SystemExit('Run this inside Revit (pyRevit or RevitPythonShell).')

app = uiapp.Application
uidoc = uiapp.ActiveUIDocument
doc = uidoc.Document if uidoc else None

FT = 0.3048  # metres per foot; Revit works in feet internally
CATEGORIES = {
    'Generic Models': BuiltInCategory.OST_GenericModel,
    'Furniture': BuiltInCategory.OST_Furniture,
    'Columns': BuiltInCategory.OST_Columns,
}


# ---------------------------------------------------------------- UI helpers

def _forms():
    try:
        from pyrevit import forms
        return forms
    except Exception:
        return None


def alert(msg):
    f = _forms()
    if f:
        f.alert(msg)
    else:
        from Autodesk.Revit.UI import TaskDialog
        TaskDialog.Show('Digimax', msg)


def pick_file(ext, title):
    f = _forms()
    if f:
        return f.pick_file(file_ext=ext, title=title)
    clr.AddReference('System.Windows.Forms')
    from System.Windows.Forms import OpenFileDialog, DialogResult
    d = OpenFileDialog()
    d.Title = title
    d.Filter = '{0} files (*.{0})|*.{0}'.format(ext)
    return d.FileName if d.ShowDialog() == DialogResult.OK else None


# ---------------------------------------------------------------- Revit helpers

def find_template():
    """Generic Model family template; metric first, any language-neutral match after."""
    roots = [app.FamilyTemplatePath, r'C:\ProgramData\Autodesk']
    hits = []
    for root in roots:
        if not root or not os.path.isdir(root):
            continue
        for d, _, files in os.walk(root):
            for f in files:
                low = f.lower()
                if low.endswith('.rft') and 'generic model' in low and 'adaptive' not in low \
                        and 'face' not in low and 'line' not in low and 'pattern' not in low \
                        and 'wall' not in low and 'ceiling' not in low and 'floor' not in low \
                        and 'roof' not in low:
                    hits.append(os.path.join(d, f))
        if hits:
            break
    hits.sort(key=lambda p: (0 if 'metric' in os.path.basename(p).lower() else 1, len(p)))
    if hits:
        return hits[0]
    return pick_file('rft', 'Pick a Generic Model family template (.rft)')


def safe_name(name, used):
    base = re.sub(r'[\\/:*?"<>|\[\]{};=]+', '_', name or 'Material').strip(' ._') or 'Material'
    base = base[:80]
    n, i = base, 2
    while n.lower() in used:
        n = '{0} ({1})'.format(base, i)
        i += 1
    used.add(n.lower())
    return n


def make_material(fam, name, rgb, transparency):
    existing = [m for m in FilteredElementCollector(fam).OfClass(Material) if m.Name == name]
    mat = existing[0] if existing else fam.GetElement(Material.Create(fam, name))
    mat.Color = Color(Byte(int(rgb[0])), Byte(int(rgb[1])), Byte(int(rgb[2])))
    mat.Transparency = max(0, min(100, int(transparency)))
    return mat.Id


def build_shape(seg, mat_id):
    p = seg['positions']
    ix = seg['indices']
    pts = [XYZ(p[i] / FT, p[i + 1] / FT, p[i + 2] / FT) for i in range(0, len(p), 3)]
    b = TessellatedShapeBuilder()
    b.OpenConnectedFaceSet(False)
    for t in range(0, len(ix), 3):
        face = List[XYZ]()
        face.Add(pts[ix[t]])
        face.Add(pts[ix[t + 1]])
        face.Add(pts[ix[t + 2]])
        b.AddFace(TessellatedFace(face, mat_id))
    b.CloseConnectedFaceSet()
    b.Target = TessellatedShapeBuilderTarget.AnyGeometry
    b.Fallback = TessellatedShapeBuilderFallback.Mesh
    b.Build()
    result = b.GetBuildResult()
    return result.GetGeometricalObjects(), pts


def create_direct_shape(fam, cat_id, geoms, name):
    try:
        ds = DirectShape.CreateElement(fam, cat_id)
    except Exception:  # Revit 2016-2021 signature
        ds = DirectShape.CreateElement(fam, cat_id, 'Digimax', 'SKP2RVT')
    ds.SetShape(geoms)
    try:
        ds.Name = name
    except Exception:
        pass
    return ds


class LoadOpts(IFamilyLoadOptions):
    def OnFamilyFound(self, familyInUse, overwriteParameterValues):
        try:
            overwriteParameterValues.Value = True
        except Exception:
            pass
        return True

    def OnSharedFamilyFound(self, sharedFamily, familyInUse, source, overwriteParameterValues):
        try:
            overwriteParameterValues.Value = True
        except Exception:
            pass
        return True


def symbol_of(family_name):
    for s in FilteredElementCollector(doc).OfClass(FamilySymbol):
        if s.Family.Name == family_name:
            return s
    return None


def lowest_level():
    levels = sorted(FilteredElementCollector(doc).OfClass(Level), key=lambda l: l.Elevation)
    return levels[0] if levels else None


# ---------------------------------------------------------------- main

def make_family(seg, template, out_dir, fam_name):
    fam = app.NewFamilyDocument(template)
    try:
        t = Transaction(fam, 'Digimax geometry')
        t.Start()
        bic = CATEGORIES.get(seg.get('category'), BuiltInCategory.OST_GenericModel)
        cat = fam.Settings.Categories.get_Item(bic)
        if bic != BuiltInCategory.OST_GenericModel:
            try:
                fam.OwnerFamily.FamilyCategory = cat
            except Exception:
                bic = BuiltInCategory.OST_GenericModel
                cat = fam.Settings.Categories.get_Item(bic)
        mat_id = make_material(fam, seg.get('materialName') or fam_name, seg['color'], seg.get('transparency', 0))
        geoms, pts = build_shape(seg, mat_id)
        if not geoms or geoms.Count == 0:
            t.RollBack()
            raise Exception('Revit could not build the mesh')
        create_direct_shape(fam, ElementId(bic), geoms, fam_name)
        t.Commit()

        path = os.path.join(out_dir, fam_name + '.rfa')
        opts = SaveAsOptions()
        opts.OverwriteExistingFile = True
        fam.SaveAs(path, opts)
        fam.LoadFamily(doc, LoadOpts())
        return path, pts
    finally:
        fam.Close(False)


def place(fam_name, pts, level):
    sym = symbol_of(fam_name)
    if sym is None:
        raise Exception('family loaded but no type found')
    if not sym.IsActive:
        sym.Activate()
        doc.Regenerate()
    if level is not None:
        inst = doc.Create.NewFamilyInstance(XYZ(0, 0, 0), sym, level, StructuralType.NonStructural)
    else:
        inst = doc.Create.NewFamilyInstance(XYZ(0, 0, 0), sym, StructuralType.NonStructural)
    doc.Regenerate()
    # Put the geometry back where it was in SketchUp, whatever the level elevation or
    # family origin did to it: compare the instance box with the source points.
    bb = inst.get_BoundingBox(None)
    if bb is not None:
        want = XYZ(min(p.X for p in pts), min(p.Y for p in pts), min(p.Z for p in pts))
        move = want - bb.Min
        if move.GetLength() > 0.003:  # ~1 mm
            ElementTransformUtils.MoveElement(doc, inst.Id, move)
    return inst


def main():
    if doc is None or doc.IsFamilyDocument:
        alert('Open a Revit project first, then run this again.')
        return
    pack_path = pick_file('json', 'Pick the Digimax families pack (.dgx-families.json)')
    if not pack_path:
        return
    with io.open(pack_path, 'r', encoding='utf-8') as fh:
        pack = json.load(fh)
    if pack.get('format') != 'digimax-revit-pack':
        alert('That file is not a Digimax families pack.')
        return
    segs = pack.get('segments') or []
    if not segs:
        alert('The pack has no elements.')
        return
    template = find_template()
    if not template:
        alert('No Generic Model family template found. Nothing was changed.')
        return

    base = os.path.splitext(os.path.basename(pack_path))[0].replace('.dgx-families', '')
    out_dir = os.path.join(os.path.dirname(pack_path), base + ' families')
    if not os.path.isdir(out_dir):
        os.makedirs(out_dir)

    level = lowest_level()
    used = set()
    done, failed = [], []
    for seg in segs:
        fam_name = safe_name(seg.get('name'), used)
        try:
            path, pts = make_family(seg, template, out_dir, fam_name)
            t = Transaction(doc, 'Digimax: place ' + fam_name)
            t.Start()
            try:
                place(fam_name, pts, level)
                t.Commit()
            except Exception:
                t.RollBack()
                raise
            done.append(fam_name)
            print('OK    {0}  ({1} triangles) -> {2}'.format(fam_name, len(seg['indices']) // 3, path))
        except Exception as e:
            failed.append(fam_name)
            print('FAIL  {0}: {1}'.format(fam_name, e))

    msg = '{0} families made, loaded and placed.\nSaved in: {1}'.format(len(done), out_dir)
    if failed:
        msg += '\n\n{0} failed (see the output window): {1}'.format(len(failed), ', '.join(failed))
    alert(msg)


main()
