LoadIfcFile

export class LoadIfcFile extends OBC.Component {
  enabled: boolean = true;
  static uuid = OBC.UUID.create();
  gpt: ChatGpt;

  constructor(components: OBC.Components) {
    super(components);
    components.add(LoadIfcFile.uuid, this);
    this.gpt = components.get(ChatGpt);
  }
}

type IfcFileData = {
  fileAsString: string,
}

async loadFile(file: File | null, world: OBC.SimpleWorld): Promise<void>

async loadFile(file: File | null, world: OBC.SimpleWorld) {
  const fragmentLoader = this.components.get(OBC.IfcLoader);
  const gpt = this.components.get(ChatGpt);
  
  if (file === null) {
    alert("Please select ifc file");
    return;
  }
  
  // Read file as text for GPT analysis
  const reader = new FileReader();
  let fileCOntent: string = "";
  reader.onload = function(event) {
    const myData = event.target?.result;
    if (typeof myData === "string") {
      fileCOntent = myData;
      gpt.fileData = myData;
    }
  };
  reader.readAsText(file);
  
  // Load file as fragments for 3D visualization
  const fileAsArray = await file.arrayBuffer();
  const buffer = new Uint8Array(fileAsArray);
  const model = await fragmentLoader.load(buffer);
  model.name = "example";
  
  // Extract material data
  const material = await this.AddIfcFileDataToGenerallString(
    model, 
    WEBIFC.IFCMATERIAL
  );
  
  // Add model to scene
  world.scene.three.add(model);
}

const loadIfc = components.get(LoadIfcFile);

const fileInput = document.createElement("input");
fileInput.type = "file";
fileInput.accept = ".ifc";

fileInput.addEventListener("change", async () => {
  const file = fileInput.files?.[0];
  if (!file) return;
  await loadIfc.loadFile(file, world);
});

AddIfcFileDataToGenerallString = async (
  model: FragmentsGroup,
  type: number,
  backupType?: number
): Promise<string | undefined>

const loadIfc = components.get(LoadIfcFile);
const model = await fragmentLoader.load(buffer);

// Extract wall data with fallback to standard case
const wallData = await loadIfc.AddIfcFileDataToGenerallString(
  model,
  WEBIFC.IFCWALL,
  WEBIFC.IFCWALLSTANDARDCASE
);

// Extract slab data
const slabData = await loadIfc.AddIfcFileDataToGenerallString(
  model,
  WEBIFC.IFCSLAB
);

// Extract beam data
const beamData = await loadIfc.AddIfcFileDataToGenerallString(
  model,
  WEBIFC.IFCBEAM
);

const indexer = this.components.get(OBC.IfcRelationsIndexer);
let generallString: string = "";

let wallsData = await model.getAllPropertiesOfType(type);
if (!wallsData && backupType) {
  wallsData = await model.getAllPropertiesOfType(backupType);
}

if (wallsData == null || Object.keys(wallsData).length == 0) return;

for (const [expressId, propeties] of Object.entries(wallsData)) {
  // Add element properties
  generallString += JSON.stringify(propeties);
  
  // Find and add building storey
  const levelOfThisWall = indexer.getEntitiesWithRelation(
    model,
    "ContainsElements",
    parseInt(expressId)
  );
  
  for (var propOfWall of levelOfThisWall) {
    const property = await model.getProperties(propOfWall);
    if (property.type === WEBIFC.IFCBUILDINGSTOREY) {
      generallString += JSON.stringify(property);
    }
  }
  
  // Add property sets and quantities
  const propertiesRelations = indexer.getEntityRelations(
    model,
    parseInt(expressId),
    "IsDefinedBy"
  );
  
  for (const relID of propertiesRelations) {
    const relatedEntity = await model.getProperties(relID);
    if (!relatedEntity) continue;
    
    if (relatedEntity.type === WEBIFC.IFCPROPERTYSET ||
        relatedEntity.type === WEBIFC.IFCELEMENTQUANTITY) {
      generallString += JSON.stringify(relatedEntity);
    }
  }
}

return generallString;

export function LoadIFCUI(components: OBC.Components, world: OBC.SimpleWorld) {
  const lodLogic = components.get(LoadIfcFile);
  
  const fileInput = document.createElement("input");
  fileInput.type = "file";
  fileInput.accept = ".ifc";
  fileInput.style.display = "none";
  
  const onAddClick = async (e: Event) => {
    fileInput.click();
  };
  
  fileInput.addEventListener("change", async () => {
    const file = fileInput.files?.[0];
    if (!file) return;
    await lodLogic.loadFile(file, world);
  });
  
  return BUI.html`
    <bim-button @click=${onAddClick} label="Add" icon="mi:add"></bim-button>
  `;
}

// In loadFile method
reader.onload = function(event) {
  const myData = event.target?.result;
  if (typeof myData === "string") {
    gpt.fileData = myData; // Stored for GPT queries
  }
};

const fragmentLoader = this.components.get(OBC.IfcLoader);
const model = await fragmentLoader.load(buffer);

// Model is automatically added to FragmentsManager
// and triggers onFragmentsLoaded events

const indexer = this.components.get(OBC.IfcRelationsIndexer);

// Get spatial containment
const levelOfThisWall = indexer.getEntitiesWithRelation(
  model,
  "ContainsElements",
  parseInt(expressId)
);

// Get property definitions
const propertiesRelations = indexer.getEntityRelations(
  model,
  parseInt(expressId),
  "IsDefinedBy"
);