import { Injectable, NotFoundException, Logger, BadRequestException } from '@nestjs/common';
import { TenantDatabaseService } from '../tenant/tenant-database.service';
import { CustomMigrationService } from '../migration/custom-migration.service';
import { ModelService } from './models/model.service';
import { AuthorizationService } from '../rbac/authorization.service';
import { SchemaManagementService } from './schema-management.service';
import { ObjectDefinition } from '../models/object-definition.model';
import { FieldDefinition } from '../models/field-definition.model';
import { User } from '../models/user.model';
import { ObjectMetadata } from './models/dynamic-model.factory';
import { MeilisearchService } from '../search/meilisearch.service';

type SearchFilter = {
  field: string;
  operator: string;
  value?: any;
  values?: any[];
  from?: string;
  to?: string;
};

type SearchSort = {
  field: string;
  direction: 'asc' | 'desc';
};

type SearchPagination = {
  page?: number;
  pageSize?: number;
};

@Injectable()
export class ObjectService {
  private readonly logger = new Logger(ObjectService.name);
  
  constructor(
    private tenantDbService: TenantDatabaseService,
    private customMigrationService: CustomMigrationService,
    private modelService: ModelService,
    private authService: AuthorizationService,
    private meilisearchService: MeilisearchService,
  ) {}

  // Setup endpoints - Object metadata management
  async getObjectDefinitions(tenantId: string) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    const objects = await knex('object_definitions')
      .select('object_definitions.*')
      .orderBy('label', 'asc');

    // Fetch app information for objects that have app_id
    for (const obj of objects) {
      if (obj.app_id) {
        const app = await knex('apps')
          .where({ id: obj.app_id })
          .select('id', 'slug', 'label', 'description')
          .first();
        obj.app = app;
      }
    }

    return objects;
  }

  async getObjectDefinition(tenantId: string, apiName: string) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    const obj = await knex('object_definitions')
      .where({ apiName })
      .first();

    if (!obj) {
      throw new NotFoundException(`Object ${apiName} not found`);
    }

    // Get fields for this object
    const fields = await knex('field_definitions')
      .where({ objectDefinitionId: obj.id })
      .orderBy('label', 'asc');

    // Normalize all fields to ensure system fields are properly marked and add any missing system fields
    const normalizedFields = this.addMissingSystemFields(
      fields.map((field: any) => this.normalizeField(field)),
    );

    // Get app information if object belongs to an app
    let app = null;
    if (obj.app_id) {
      app = await knex('apps')
        .where({ id: obj.app_id })
        .select('id', 'slug', 'label', 'description')
        .first();
    }

    const relatedLists = await this.getRelatedListDefinitions(resolvedTenantId, apiName);

    return {
      ...obj,
      fields: normalizedFields,
      app,
      relatedLists,
    };
  }

  async createObjectDefinition(
    tenantId: string,
    data: {
      apiName: string;
      label: string;
      pluralLabel?: string;
      description?: string;
      isSystem?: boolean;
    },
  ) {
    // Resolve tenant ID in case a slug was passed
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Generate UUID for the new object
    const objectId = require('crypto').randomUUID();
    
    // Create the object definition record
    await knex('object_definitions').insert({
      id: objectId,
      ...data,
      created_at: knex.fn.now(),
      updated_at: knex.fn.now(),
    });
    
    const objectDef = await knex('object_definitions').where({ id: objectId }).first();
    
    // Create standard field definitions (only if they don't already exist)
    const standardFields = [
      {
        apiName: 'ownerId',
        label: 'Owner',
        type: 'LOOKUP',
        description: 'The user who owns this record',
        isRequired: false,  // Auto-set by system
        isUnique: false,
        referenceObject: 'User',
        isSystem: true,
        isCustom: false,
      },
      {
        apiName: 'name',
        label: 'Name',
        type: 'STRING',
        description: 'The primary name field for this record',
        isRequired: false,  // Optional field
        isUnique: false,
        referenceObject: null,
        isSystem: false,
        isCustom: false,
      },
      {
        apiName: 'created_at',
        label: 'Created At',
        type: 'DATE_TIME',
        description: 'The timestamp when this record was created',
        isRequired: false,  // Auto-set by system
        isUnique: false,
        referenceObject: null,
        isSystem: true,
        isCustom: false,
      },
      {
        apiName: 'updated_at',
        label: 'Updated At',
        type: 'DATE_TIME',
        description: 'The timestamp when this record was last updated',
        isRequired: false,  // Auto-set by system
        isUnique: false,
        referenceObject: null,
        isSystem: true,
        isCustom: false,
      },
    ];

    // Insert standard field definitions that don't already exist
    for (const field of standardFields) {
      const existingField = await knex('field_definitions')
        .where({
          objectDefinitionId: objectDef.id,
          apiName: field.apiName,
        })
        .first();

      if (!existingField) {
        const fieldData: any = {
          id: knex.raw('(UUID())'),
          objectDefinitionId: objectDef.id,
          ...field,
          created_at: knex.fn.now(),
          updated_at: knex.fn.now(),
        };
        
        // For lookup fields, set ui_metadata with relationDisplayField
        if (field.type === 'LOOKUP') {
          fieldData.ui_metadata = JSON.stringify({
            relationDisplayField: 'name',
          });
        }
        
        await knex('field_definitions').insert(fieldData);
      }
    }
    
    // Create a migration to create the table
    const tableName = this.getTableName(data.apiName, data.label, data.pluralLabel);
    const createTableSQL = this.customMigrationService.generateCreateTableSQL(tableName);
    
    try {
      await this.customMigrationService.createAndExecuteMigration(
        knex,
        resolvedTenantId,
        {
          name: `create_${tableName}_table`,
          description: `Create table for ${data.label} object`,
          type: 'create_table',
          sql: createTableSQL,
        },
      );
    } catch (error) {
      // Log the error but don't fail - migration is recorded for future retry
      console.error(`Failed to execute table creation migration: ${error.message}`);
    }

    // Create and register the Objection model for this object
    try {
      const allFields = await knex('field_definitions')
        .where({ objectDefinitionId: objectDef.id })
        .select('apiName', 'label', 'type', 'isRequired', 'isUnique', 'referenceObject');

      const objectMetadata: ObjectMetadata = {
        apiName: data.apiName,
        tableName,
        fields: allFields.map((f: any) => ({
          apiName: f.apiName,
          label: f.label,
          type: f.type,
          isRequired: f.isRequired,
          isUnique: f.isUnique,
          referenceObject: f.referenceObject,
        })),
        relations: [],
      };

      await this.modelService.createModelForObject(resolvedTenantId, objectMetadata);
    } catch (error) {
      console.error(`Failed to create model for object ${data.apiName}:`, error.message);
    }
    
    return objectDef;
  }

  async updateObjectDefinition(
    tenantId: string,
    objectApiName: string,
    data: Partial<{
      label: string;
      pluralLabel: string;
      description: string;
      orgWideDefault: 'private' | 'public_read' | 'public_read_write';
    }>,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Update the object definition
    await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName })
      .patch({
        ...data,
        updatedAt: new Date(),
      });
    
    // Return updated object
    return await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName });
  }

  async createFieldDefinition(
    tenantId: string,
    objectApiName: string,
    data: {
      apiName: string;
      label: string;
      type: string;
      description?: string;
      isRequired?: boolean;
      isUnique?: boolean;
      referenceObject?: string;
      relationObject?: string;
      relationDisplayField?: string;
      relationObjects?: string[];
      relationTypeField?: string;
      defaultValue?: string;
      length?: number;
      precision?: number;
      scale?: number;
      uiMetadata?: any;
    },
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    const obj = await this.getObjectDefinition(tenantId, objectApiName);

    // Convert frontend type to database type
    const dbFieldType = this.convertFrontendFieldType(data.type);
    
    // Use relationObject if provided (alias for referenceObject)
    const referenceObject = data.referenceObject || data.relationObject;

    // Generate UUID in Node.js instead of using MySQL UUID() function
    const fieldId = require('crypto').randomUUID();

    const fieldData: any = {
      id: fieldId,
      objectDefinitionId: obj.id,
      apiName: data.apiName,
      label: data.label,
      type: dbFieldType,
      description: data.description,
      isRequired: data.isRequired ?? false,
      isUnique: data.isUnique ?? false,
      referenceObject: referenceObject,
      defaultValue: data.defaultValue,
      length: data.length,
      precision: data.precision,
      scale: data.scale,
      created_at: knex.fn.now(),
      updated_at: knex.fn.now(),
    };
    
    // Store relationDisplayField in UI metadata if provided
    if (data.relationDisplayField || data.relationObjects || data.relationTypeField) {
      fieldData.ui_metadata = JSON.stringify({
        relationDisplayField: data.relationDisplayField,
        relationObjects: data.relationObjects,
        relationTypeField: data.relationTypeField,
      });
    }
    
    await knex('field_definitions').insert(fieldData);
    const createdField = await knex('field_definitions').where({ id: fieldId }).first();

    // Add the column to the physical table
    const schemaManagementService = new SchemaManagementService();
    try {
      await schemaManagementService.addFieldToTable(
        knex,
        obj.apiName,
        createdField,
        obj.label,
        obj.pluralLabel,
      );
      this.logger.log(`Added column ${data.apiName} to table for object ${objectApiName}`);
    } catch (error) {
      // If column creation fails, delete the field definition to maintain consistency
      this.logger.error(`Failed to add column ${data.apiName}: ${error.message}`);
      await knex('field_definitions').where({ id: fieldId }).delete();
      throw new Error(`Failed to create field column: ${error.message}`);
    }
    
    return createdField;
  }

  // Helper to get table name from object definition
  private getTableName(objectApiName: string, objectLabel?: string, pluralLabel?: string): string {
    const toSnakePlural = (source: string): string => {
      const cleaned = source.replace(/[\s-]+/g, '_');
      const snake = cleaned
        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
        .replace(/__+/g, '_')
        .toLowerCase()
        .replace(/^_/, '');

      if (snake.endsWith('y')) return `${snake.slice(0, -1)}ies`;
      if (snake.endsWith('s')) return snake;
      return `${snake}s`;
    };

    const fromApi = toSnakePlural(objectApiName);
    const fromLabel = objectLabel ? toSnakePlural(objectLabel) : null;
    const fromPlural = pluralLabel ? toSnakePlural(pluralLabel) : null;

    // Prefer the label-derived name when it introduces clearer word boundaries
    if (fromLabel && fromLabel.includes('_') && !fromApi.includes('_')) {
      return fromLabel;
    }
    if (fromPlural && fromPlural.includes('_') && !fromApi.includes('_')) {
      return fromPlural;
    }

    // Otherwise fall back to label/plural if they differ from API-derived
    if (fromLabel && fromLabel !== fromApi) return fromLabel;
    if (fromPlural && fromPlural !== fromApi) return fromPlural;

    return fromApi;
  }

  /**
   * Normalize field definition to ensure system fields are properly marked
   */
  private normalizeField(field: any): any {
    const systemFieldNames = ['id', 'tenantId', 'ownerId', 'created_at', 'updated_at', 'createdAt', 'updatedAt'];
    const isSystemField = systemFieldNames.includes(field.apiName);
    
    return {
      ...field,
      // Ensure system fields are marked correctly
      isSystem: isSystemField ? true : field.isSystem,
      isRequired: isSystemField ? false : field.isRequired,
      isCustom: isSystemField ? false : field.isCustom ?? true,
    };
  }

  /**
   * Convert frontend field type to database field type
   */
  private convertFrontendFieldType(frontendType: string): string {
    const typeMap: Record<string, string> = {
      'text': 'TEXT',
      'textarea': 'LONG_TEXT',
      'password': 'TEXT',
      'email': 'EMAIL',
      'number': 'NUMBER',
      'currency': 'CURRENCY',
      'percent': 'PERCENT',
      'select': 'PICKLIST',
      'multiSelect': 'MULTI_PICKLIST',
      'boolean': 'BOOLEAN',
      'date': 'DATE',
      'datetime': 'DATE_TIME',
      'time': 'TIME',
      'url': 'URL',
      'color': 'TEXT',
      'json': 'JSON',
      'lookup': 'LOOKUP',
      'belongsTo': 'LOOKUP',
      'hasMany': 'LOOKUP',
      'manyToMany': 'LOOKUP',
      'markdown': 'LONG_TEXT',
      'code': 'LONG_TEXT',
      'file': 'FILE',
      'image': 'IMAGE',
    };
    
    return typeMap[frontendType] || 'TEXT';
  }

  /**
   * Ensure a model is registered for the given object.
   * Delegates to ModelService which handles creating the model and all its dependencies.
   */
  private async ensureModelRegistered(
    tenantId: string,
    objectApiName: string,
    objectDefinition?: any,
  ): Promise<void> {
    // Provide a metadata fetcher function that the ModelService can use
    const fetchMetadata = async (apiName: string): Promise<ObjectMetadata> => {
      const objectDef = await this.getObjectDefinition(tenantId, apiName);
      const tableName = this.getTableName(
        objectDef.apiName,
        objectDef.label,
        objectDef.pluralLabel,
      );

      // Build relations from lookup fields, but only for models that exist
      const lookupFields = objectDef.fields.filter((f: any) => 
        f.type === 'LOOKUP' && f.referenceObject
      );
      
      // Filter to only include relations where we can successfully resolve the target
      const validRelations: any[] = [];
      for (const field of lookupFields) {
        // Check if the referenced object will be available
        // We'll let the recursive registration attempt it, but won't include failed ones
        validRelations.push({
          name: field.apiName.replace(/Id$/, '').toLowerCase(),
          type: 'belongsTo' as const,
          targetObjectApiName: field.referenceObject,
          fromColumn: field.apiName,
          toColumn: 'id',
        });
      }

      const relatedLists = await this.getRelatedListDefinitions(tenantId, apiName);
      for (const relatedList of relatedLists) {
        validRelations.push({
          name: relatedList.relationName,
          type: 'hasMany' as const,
          targetObjectApiName: relatedList.objectApiName,
          fromColumn: 'id',
          toColumn: relatedList.lookupFieldApiName,
        });
      }

      return {
        apiName,
        tableName,
        fields: objectDef.fields.map((f: any) => ({
          apiName: f.apiName,
          label: f.label,
          type: f.type,
          isRequired: f.isRequired,
          isUnique: f.isUnique,
          referenceObject: f.referenceObject,
        })),
        relations: validRelations,
      };
    };

    // Let the ModelService handle recursive model creation
    try {
      await this.modelService.ensureModelWithDependencies(
        tenantId,
        objectDefinition?.apiName || objectApiName,
        fetchMetadata,
      );
    } catch (error) {
      this.logger.warn(
        `Failed to ensure model for ${objectApiName}: ${error.message}. Will fall back to manual hydration.`,
      );
    }
  }

  private async buildAuthorizedQuery(
    tenantId: string,
    objectApiName: string,
    userId: string,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);

    const user = await User.query(knex)
      .findById(userId)
      .withGraphFetched('[roles.[objectPermissions, fieldPermissions]]');

    if (!user) {
      throw new NotFoundException('User not found');
    }

    const objectDefModel = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName })
      .withGraphFetched('fields');

    if (!objectDefModel) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }

    // Normalize and enrich fields to include system fields for downstream permissions/search
    const normalizedFields = this.addMissingSystemFields(
      (objectDefModel.fields || []).map((field: any) => this.normalizeField(field)),
    );
    objectDefModel.fields = normalizedFields;

    await this.ensureModelRegistered(resolvedTenantId, objectApiName, objectDefModel);

    const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
    let query = boundModel.query();

    await this.authService.applyScopeToQuery(
      query,
      objectDefModel,
      user,
      'read',
      knex,
    );

    const lookupFields = objectDefModel.fields?.filter((field) =>
      field.type === 'LOOKUP' && field.referenceObject,
    ) || [];

    if (lookupFields.length > 0) {
      const relationExpression = lookupFields
        .map((field) => field.apiName.replace(/Id$/, '').toLowerCase())
        .filter(Boolean)
        .join(', ');

      if (relationExpression) {
        query = query.withGraphFetched(`[${relationExpression}]`);
      }
    }

    return {
      query,
      objectDefModel,
      user,
      knex,
    };
  }

  private applySearchFilters(
    query: any,
    filters: SearchFilter[],
    validFields: Set<string>,
  ) {
    if (!Array.isArray(filters) || filters.length === 0) {
      return query;
    }

    for (const filter of filters) {
      const field = filter?.field;
      if (!field || !validFields.has(field)) {
        continue;
      }

      const operator = String(filter.operator || 'eq').toLowerCase();
      const value = filter.value;
      const values = Array.isArray(filter.values) ? filter.values : undefined;

      switch (operator) {
        case 'eq':
          query.where(field, value);
          break;
        case 'neq':
          query.whereNot(field, value);
          break;
        case 'gt':
          query.where(field, '>', value);
          break;
        case 'gte':
          query.where(field, '>=', value);
          break;
        case 'lt':
          query.where(field, '<', value);
          break;
        case 'lte':
          query.where(field, '<=', value);
          break;
        case 'contains':
          if (value !== undefined && value !== null) {
            query.whereRaw('LOWER(??) like ?', [field, `%${String(value).toLowerCase()}%`]);
          }
          break;
        case 'startswith':
          if (value !== undefined && value !== null) {
            query.whereRaw('LOWER(??) like ?', [field, `${String(value).toLowerCase()}%`]);
          }
          break;
        case 'endswith':
          if (value !== undefined && value !== null) {
            query.whereRaw('LOWER(??) like ?', [field, `%${String(value).toLowerCase()}`]);
          }
          break;
        case 'in':
          if (values?.length) {
            query.whereIn(field, values);
          } else if (Array.isArray(value)) {
            query.whereIn(field, value);
          }
          break;
        case 'notin':
          if (values?.length) {
            query.whereNotIn(field, values);
          } else if (Array.isArray(value)) {
            query.whereNotIn(field, value);
          }
          break;
        case 'isnull':
          query.whereNull(field);
          break;
        case 'notnull':
          query.whereNotNull(field);
          break;
        case 'between': {
          const from = filter.from ?? (Array.isArray(value) ? value[0] : undefined);
          const to = filter.to ?? (Array.isArray(value) ? value[1] : undefined);
          if (from !== undefined && to !== undefined) {
            query.whereBetween(field, [from, to]);
          } else if (from !== undefined) {
            query.where(field, '>=', from);
          } else if (to !== undefined) {
            query.where(field, '<=', to);
          }
          break;
        }
        default:
          break;
      }
    }

    return query;
  }

  private applyKeywordFilter(
    query: any,
    keyword: string,
    fields: string[],
  ) {
    const trimmed = keyword?.trim();
    if (!trimmed || fields.length === 0) {
      return query;
    }

    query.where((builder: any) => {
      const lowered = trimmed.toLowerCase();
      for (const field of fields) {
        builder.orWhereRaw('LOWER(??) like ?', [field, `%${lowered}%`]);
      }
    });

    return query;
  }

  private async finalizeRecordQuery(
    query: any,
    objectDefModel: any,
    user: any,
    pagination?: SearchPagination,
  ) {
    const parsedPage = Number.isFinite(Number(pagination?.page)) ? Number(pagination?.page) : 1;
    const parsedPageSize = Number.isFinite(Number(pagination?.pageSize))
      ? Number(pagination?.pageSize)
      : 0;
    const safePage = parsedPage > 0 ? parsedPage : 1;
    const safePageSize = parsedPageSize > 0 ? Math.min(parsedPageSize, 500) : 0;
    const shouldPaginate = safePageSize > 0;

    const totalCount = await query.clone().resultSize();

    if (shouldPaginate) {
      query = query.offset((safePage - 1) * safePageSize).limit(safePageSize);
    }

    const records = await query.select('*');
    const filteredRecords = await Promise.all(
      records.map((record: any) =>
        this.authService.filterReadableFields(record, objectDefModel.fields, user),
      ),
    );

    return {
      data: filteredRecords,
      totalCount,
      page: shouldPaginate ? safePage : 1,
      pageSize: shouldPaginate ? safePageSize : filteredRecords.length,
    };
  }

  // Runtime endpoints - CRUD operations
  async getRecords(
    tenantId: string,
    objectApiName: string,
    userId: string,
    filters?: any,
  ) {
    let { query, objectDefModel, user } = await this.buildAuthorizedQuery(
      tenantId,
      objectApiName,
      userId,
    );
    
    // Extract pagination and sorting parameters from query string
    const {
      page,
      pageSize,
      sortField,
      sortDirection,
      ...rawFilters
    } = filters || {};

    const reservedFilterKeys = new Set(['page', 'pageSize', 'sortField', 'sortDirection']);
    const filterEntries = Object.entries(rawFilters || {}).filter(
      ([key, value]) =>
        !reservedFilterKeys.has(key) &&
        value !== undefined &&
        value !== null &&
        value !== '',
    );

    if (filterEntries.length > 0) {
      query = query.where(builder => {
        for (const [key, value] of filterEntries) {
          builder.where(key, value as any);
        }
      });
    }

    if (sortField) {
      const direction = sortDirection === 'desc' ? 'desc' : 'asc';
      query = query.orderBy(sortField, direction);
    }

    return this.finalizeRecordQuery(query, objectDefModel, user, { page, pageSize });
  }

  async searchRecordsByIds(
    tenantId: string,
    objectApiName: string,
    userId: string,
    recordIds: string[],
    pagination?: SearchPagination,
  ) {
    if (!Array.isArray(recordIds) || recordIds.length === 0) {
      return {
        data: [],
        totalCount: 0,
        page: pagination?.page ?? 1,
        pageSize: pagination?.pageSize ?? 0,
      };
    }

    const { query, objectDefModel, user } = await this.buildAuthorizedQuery(
      tenantId,
      objectApiName,
      userId,
    );

    query.whereIn('id', recordIds);
    const orderBindings: any[] = ['id'];
    const cases = recordIds
      .map((id, index) => {
        orderBindings.push(id, index);
        return 'when ? then ?';
      })
      .join(' ');

    if (cases) {
      query.orderByRaw(`case ?? ${cases} end`, orderBindings);
    }

    return this.finalizeRecordQuery(query, objectDefModel, user, pagination);
  }

  async searchRecordsWithFilters(
    tenantId: string,
    objectApiName: string,
    userId: string,
    filters: SearchFilter[],
    pagination?: SearchPagination,
    sort?: SearchSort,
  ) {
    const { query, objectDefModel, user } = await this.buildAuthorizedQuery(
      tenantId,
      objectApiName,
      userId,
    );

    const validFields = new Set([
      ...(objectDefModel.fields?.map((field: any) => field.apiName) || []),
      ...this.getSystemFieldNames(),
    ]);
    this.applySearchFilters(query, filters, validFields);

    if (sort?.field && validFields.has(sort.field)) {
      query.orderBy(sort.field, sort.direction === 'desc' ? 'desc' : 'asc');
    }

    return this.finalizeRecordQuery(query, objectDefModel, user, pagination);
  }

  async searchRecordsByKeyword(
    tenantId: string,
    objectApiName: string,
    userId: string,
    keyword: string,
    pagination?: SearchPagination,
  ) {
    const { query, objectDefModel, user } = await this.buildAuthorizedQuery(
      tenantId,
      objectApiName,
      userId,
    );

    const keywordFields = (objectDefModel.fields || [])
      .filter((field: any) => this.isKeywordField(field.type))
      .map((field: any) => field.apiName);

    this.applyKeywordFilter(query, keyword, keywordFields);

    return this.finalizeRecordQuery(query, objectDefModel, user, pagination);
  }

  async getRecord(
    tenantId: string,
    objectApiName: string,
    recordId: string,
    userId: string,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Get user with roles and permissions
    const user = await User.query(knex)
      .findById(userId)
      .withGraphFetched('[roles.[objectPermissions, fieldPermissions]]');
    
    if (!user) {
      throw new NotFoundException('User not found');
    }
    
    // Get object definition with authorization settings
    const objectDefModel = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName })
      .withGraphFetched('fields');
    
    if (!objectDefModel) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }
    
    // Ensure model is registered
    await this.ensureModelRegistered(resolvedTenantId, objectApiName, objectDefModel);
    
    // Use Objection model
    const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
    let query = boundModel.query().where({ id: recordId });
    
    // Apply authorization scope (modifies query in place)
    await this.authService.applyScopeToQuery(
      query,
      objectDefModel,
      user,
      'read',
      knex,
    );
    
    // Build graph expression for lookup fields
    const lookupFields = objectDefModel.fields?.filter(f => 
      f.type === 'LOOKUP' && f.referenceObject
    ) || [];
    
    const relatedLists = await this.getRelatedListDefinitions(resolvedTenantId, objectApiName);

    const relationNames = [
      ...lookupFields
        .map(f => f.apiName.replace(/Id$/, '').toLowerCase())
        .filter(Boolean),
      ...relatedLists.map(list => list.relationName),
    ];

    if (relationNames.length > 0) {
      const relationExpression = relationNames.join(', ');
      query = query.withGraphFetched(`[${relationExpression}]`);
    }
    
    const record = await query.first();
    if (!record) {
      throw new NotFoundException('Record not found');
    }
    
    // Filter fields based on field-level permissions
    const filteredRecord = await this.authService.filterReadableFields(record, objectDefModel.fields, user);
    
    return filteredRecord;
  }

  private async getRelatedListDefinitions(
    tenantId: string,
    objectApiName: string,
  ): Promise<Array<{
    title: string;
    relationName: string;
    objectApiName: string;
    lookupFieldApiName: string;
    parentObjectApiName: string;
    fields: any[];
  }>> {
    const knex = await this.tenantDbService.getTenantKnexById(tenantId);

    const relatedLookupsRaw = await knex('field_definitions as fd')
      .join('object_definitions as od', 'fd.objectDefinitionId', 'od.id')
      .where('fd.type', 'LOOKUP')
      .select(
        'fd.apiName as fieldApiName',
        'fd.label as fieldLabel',
        'fd.objectDefinitionId as objectDefinitionId',
        'fd.referenceObject as referenceObject',
        'fd.ui_metadata as uiMetadata',
        'od.apiName as childApiName',
        'od.label as childLabel',
        'od.pluralLabel as childPluralLabel',
      );

    const relatedLookups = relatedLookupsRaw
      .map((lookup: any) => {
        let uiMetadata: any = {};
        if (lookup.uiMetadata) {
          try {
            uiMetadata = typeof lookup.uiMetadata === 'string'
              ? JSON.parse(lookup.uiMetadata)
              : lookup.uiMetadata;
          } catch {
            uiMetadata = {};
          }
        }
        return { ...lookup, uiMetadata };
      })
      .filter((lookup: any) => {
        const target = (objectApiName || '').toLowerCase();
        const referenceMatch =
          typeof lookup.referenceObject === 'string' &&
          lookup.referenceObject.toLowerCase() === target;

        if (referenceMatch) return true;

        const relationObjects = lookup.uiMetadata?.relationObjects;
        if (!Array.isArray(relationObjects)) return false;

        return relationObjects.some(
          (rel: string) => typeof rel === 'string' && rel.toLowerCase() === target,
        );
      });

    if (relatedLookups.length === 0) {
      return [];
    }

    const objectIds = Array.from(
      new Set(relatedLookups.map((lookup: any) => lookup.objectDefinitionId)),
    );

    const relatedFields = await knex('field_definitions')
      .whereIn('objectDefinitionId', objectIds)
      .orderBy('label', 'asc');

    const fieldsByObject = new Map<string, any[]>();
    for (const field of relatedFields) {
      const existing = fieldsByObject.get(field.objectDefinitionId) || [];
      existing.push(this.normalizeField(field));
      fieldsByObject.set(field.objectDefinitionId, existing);
    }

    const lookupCounts = relatedLookups.reduce<Record<string, number>>(
      (acc, lookup: any) => {
        acc[lookup.childApiName] = (acc[lookup.childApiName] || 0) + 1;
        return acc;
      },
      {},
    );

    return relatedLookups.map((lookup: any) => {
      const baseRelationName = this.getTableName(
        lookup.childApiName,
        lookup.childLabel,
        lookup.childPluralLabel,
      );
      const hasMultiple = lookupCounts[lookup.childApiName] > 1;
      const relationName = hasMultiple
        ? `${baseRelationName}_${lookup.fieldApiName.replace(/Id$/, '').toLowerCase()}`
        : baseRelationName;
      const baseTitle =
        lookup.childPluralLabel ||
        (lookup.childLabel ? `${lookup.childLabel}s` : lookup.childApiName);
      const title = hasMultiple ? `${baseTitle} (${lookup.fieldLabel})` : baseTitle;

      return {
        title,
        relationName,
        objectApiName: lookup.childApiName,
        lookupFieldApiName: lookup.fieldApiName,
        parentObjectApiName: objectApiName,
        fields: fieldsByObject.get(lookup.objectDefinitionId) || [],
      };
    });
  }

  async createRecord(
    tenantId: string,
    objectApiName: string,
    data: any,
    userId: string,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Get user with roles and permissions
    const user = await User.query(knex)
      .findById(userId)
      .withGraphFetched('[roles.[objectPermissions, fieldPermissions]]');
    
    if (!user) {
      throw new NotFoundException('User not found');
    }
    
    // Get object definition with authorization settings
    const objectDefModel = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName })
      .withGraphFetched('fields');
    
    if (!objectDefModel) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }
    
    // Check if user has create permission
    const canCreate = await this.authService.canCreate(objectDefModel, user);
    if (!canCreate) {
      throw new NotFoundException('You do not have permission to create records of this object');
    }
    
    // Filter data to only editable fields
    const editableData = await this.authService.filterEditableFields(data, objectDefModel.fields, user);
    
    // Ensure model is registered
    await this.ensureModelRegistered(resolvedTenantId, objectApiName, objectDefModel);
    
    // Use Objection model
    const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
    const hasOwnerField = objectDefModel.fields?.some((f: any) => f.apiName === 'ownerId');
    const recordData = {
      ...editableData,
      ...(hasOwnerField ? { ownerId: userId } : {}),
    };
    const normalizedRecordData = await this.normalizePolymorphicRelatedObject(
      resolvedTenantId,
      objectApiName,
      recordData,
    );
    const record = await boundModel.query().insert(normalizedRecordData);
    await this.indexRecord(resolvedTenantId, objectApiName, objectDefModel.fields, record);
    return record;
  }

  async updateRecord(
    tenantId: string,
    objectApiName: string,
    recordId: string,
    data: any,
    userId: string,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Get user with roles and permissions
    const user = await User.query(knex)
      .findById(userId)
      .withGraphFetched('[roles.[objectPermissions, fieldPermissions]]');
    
    if (!user) {
      throw new NotFoundException('User not found');
    }
    
    // Get object definition with authorization settings
    const objectDefModel = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName })
      .withGraphFetched('fields');
    
    if (!objectDefModel) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }
    
    const tableName = this.getTableName(
      objectDefModel.apiName,
      objectDefModel.label,
      objectDefModel.pluralLabel,
    );
    
    // Get existing record
    const existingRecord = await knex(tableName).where({ id: recordId }).first();
    if (!existingRecord) {
      throw new NotFoundException('Record not found');
    }
    
    // Check if user can update this record
    await this.authService.assertCanPerformAction('update', objectDefModel, existingRecord, user, knex);
    
    // Filter data to only editable fields
    const editableData = await this.authService.filterEditableFields(data, objectDefModel.fields, user);
    
    // Remove system fields
    delete editableData.id;
    delete editableData.ownerId;
    delete editableData.created_at;
    delete editableData.tenantId;

    // Ensure model is registered
    await this.ensureModelRegistered(resolvedTenantId, objectApiName, objectDefModel);

    // Use Objection model
    const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
    const normalizedEditableData = await this.normalizePolymorphicRelatedObject(
      resolvedTenantId,
      objectApiName,
      editableData,
    );
    // Use patch to avoid validating or overwriting fields that aren't present in the edit view
    await boundModel.query().patch(normalizedEditableData).where({ id: recordId });
    const record = await boundModel.query().where({ id: recordId }).first();
    await this.indexRecord(resolvedTenantId, objectApiName, objectDefModel.fields, record);
    return record;
  }

  async deleteRecord(
    tenantId: string,
    objectApiName: string,
    recordId: string,
    userId: string,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Get user with roles and permissions
    const user = await User.query(knex)
      .findById(userId)
      .withGraphFetched('[roles.[objectPermissions, fieldPermissions]]');
    
    if (!user) {
      throw new NotFoundException('User not found');
    }
    
    // Get object definition with authorization settings
    const objectDefModel = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName });
    
    if (!objectDefModel) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }
    
    const tableName = this.getTableName(
      objectDefModel.apiName,
      objectDefModel.label,
      objectDefModel.pluralLabel,
    );
    
    // Get existing record
    const existingRecord = await knex(tableName).where({ id: recordId }).first();
    if (!existingRecord) {
      throw new NotFoundException('Record not found');
    }
    
    // Check if user can delete this record
    await this.authService.assertCanPerformAction('delete', objectDefModel, existingRecord, user, knex);

    // Ensure model is registered
    await this.ensureModelRegistered(resolvedTenantId, objectApiName, objectDefModel);

    // Use Objection model
    const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
    await boundModel.query().where({ id: recordId }).delete();
    await this.removeIndexedRecord(resolvedTenantId, objectApiName, recordId);
    
    return { success: true };
  }

  async deleteRecords(
    tenantId: string,
    objectApiName: string,
    recordIds: string[],
    userId: string,
  ) {
    if (!Array.isArray(recordIds) || recordIds.length === 0) {
      throw new BadRequestException('No record IDs provided');
    }

    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Get user with roles and permissions
    const user = await User.query(knex)
      .findById(userId)
      .withGraphFetched('[roles.[objectPermissions, fieldPermissions]]');
    
    if (!user) {
      throw new NotFoundException('User not found');
    }
    
    // Get object definition with authorization settings
    const objectDefModel = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName });
    
    if (!objectDefModel) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }
    
    const tableName = this.getTableName(
      objectDefModel.apiName,
      objectDefModel.label,
      objectDefModel.pluralLabel,
    );

    const records = await knex(tableName).whereIn('id', recordIds);
    if (records.length === 0) {
      throw new NotFoundException('No records found to delete');
    }

    const foundIds = new Set(records.map((record: any) => record.id));
    const missingIds = recordIds.filter(id => !foundIds.has(id));
    if (missingIds.length > 0) {
      throw new NotFoundException(`Records not found: ${missingIds.join(', ')}`);
    }

    const deletableIds: string[] = [];
    const deniedIds: string[] = [];

    for (const record of records) {
      const canDelete = await this.authService.canPerformAction(
        'delete',
        objectDefModel,
        record,
        user,
        knex,
      );
      if (canDelete) {
        deletableIds.push(record.id);
      } else {
        deniedIds.push(record.id);
      }
    }

    // Ensure model is registered
    await this.ensureModelRegistered(resolvedTenantId, objectApiName, objectDefModel);

    // Use Objection model
    const boundModel = await this.modelService.getBoundModel(resolvedTenantId, objectApiName);
    if (deletableIds.length > 0) {
      await boundModel.query().whereIn('id', deletableIds).delete();
    }

    // Remove from search index
    await Promise.all(
      deletableIds.map((id) =>
        this.removeIndexedRecord(resolvedTenantId, objectApiName, id),
      ),
    );
    
    return {
      success: true,
      deleted: deletableIds.length,
      deletedIds: deletableIds,
      deniedIds,
    };
  }

  private async indexRecord(
    tenantId: string,
    objectApiName: string,
    fields: FieldDefinition[],
    record: Record<string, any>,
  ) {
    if (!this.meilisearchService.isEnabled() || !record?.id) return;

    const fieldsToIndex = (fields || [])
      .map((field: any) => field.apiName)
      .filter((apiName) => apiName && !this.isSystemField(apiName));

    console.log('Indexing record', {
      tenantId,
      objectApiName,
      recordId: record.id,
      fieldsToIndex,
    });

    await this.meilisearchService.upsertRecord(
      tenantId,
      objectApiName,
      record,
      fieldsToIndex,
    );

    console.log('Indexed record successfully');


    const meiliResults = await this.meilisearchService.searchRecords(
          tenantId,
          objectApiName,
          record.name,
          { limit: 10 },
        );

        console.log('Meilisearch results:', meiliResults);

  }

  private async removeIndexedRecord(
    tenantId: string,
    objectApiName: string,
    recordId: string,
  ) {
    if (!this.meilisearchService.isEnabled()) return;
    await this.meilisearchService.deleteRecord(tenantId, objectApiName, recordId);
  }

  private isSystemField(apiName: string): boolean {
    return this.getSystemFieldNames().includes(apiName);
  }

  private getSystemFieldNames(): string[] {
    return ['id', 'ownerId', 'created_at', 'updated_at', 'createdAt', 'updatedAt', 'tenantId'];
  }

  private addMissingSystemFields(fields: any[]): any[] {
    const existing = new Map((fields || []).map((field) => [field.apiName, field]));
    const systemDefaults = [
      { apiName: 'id', label: 'ID', type: 'STRING' },
      { apiName: 'created_at', label: 'Created At', type: 'DATE_TIME' },
      { apiName: 'updated_at', label: 'Updated At', type: 'DATE_TIME' },
      { apiName: 'ownerId', label: 'Owner', type: 'LOOKUP', referenceObject: 'User' },
    ];

    const merged = [...fields];
    for (const sysField of systemDefaults) {
      if (!existing.has(sysField.apiName)) {
        merged.push({
          ...sysField,
          isSystem: true,
          isCustom: false,
          isRequired: false,
        });
      }
    }

    return merged;
  }

  private isKeywordField(type: string | undefined): boolean {
    const normalized = String(type || '').toUpperCase();
    return [
      'STRING',
      'TEXT',
      'EMAIL',
      'PHONE',
      'URL',
      'RICH_TEXT',
      'TEXTAREA',
    ].includes(normalized);
  }

  private async normalizePolymorphicRelatedObject(
    tenantId: string,
    objectApiName: string,
    data: any,
  ): Promise<any> {
    if (!data || !this.isContactDetailApi(objectApiName)) return data;

    const relatedObjectType = data.relatedObjectType;
    const relatedObjectId = data.relatedObjectId;
    if (!relatedObjectType || !relatedObjectId) return data;

    const normalizedType = this.toPolymorphicApiName(relatedObjectType);
    if (!normalizedType) return data;

    if (this.isUuid(String(relatedObjectId))) {
      return {
        ...data,
        relatedObjectType: normalizedType,
      };
    }

    let targetDefinition: any;
    try {
      targetDefinition = await this.getObjectDefinition(tenantId, normalizedType.toLowerCase());
    } catch (error) {
      this.logger.warn(`Failed to load definition for ${normalizedType}: ${error.message}`);
    }

    if (!targetDefinition) {
      throw new BadRequestException(
        `Unable to resolve ${normalizedType} for "${relatedObjectId}". Please provide a valid record.`,
      );
    }

    const displayField = this.getDisplayFieldForObjectDefinition(targetDefinition);
    const tableName = this.getTableName(
      targetDefinition.apiName,
      targetDefinition.label,
      targetDefinition.pluralLabel,
    );

    let resolvedId: string | null = null;

    if (this.meilisearchService.isEnabled()) {
      const match = await this.meilisearchService.searchRecord(
        tenantId,
        targetDefinition.apiName,
        String(relatedObjectId),
        displayField,
      );
      if (match?.id) {
        resolvedId = match.id;
      }
    }

    if (!resolvedId) {
      const knex = await this.tenantDbService.getTenantKnexById(tenantId);
      const record = await knex(tableName)
        .whereRaw('LOWER(??) = ?', [displayField, String(relatedObjectId).toLowerCase()])
        .first();
      if (record?.id) {
        resolvedId = record.id;
      }
    }

    if (!resolvedId) {
      throw new BadRequestException(
        `Could not find ${normalizedType} matching "${relatedObjectId}". Please use an existing record.`,
      );
    }

    return {
      ...data,
      relatedObjectId: resolvedId,
      relatedObjectType: normalizedType,
    };
  }

  private isContactDetailApi(objectApiName: string): boolean {
    if (!objectApiName) return false;
    const normalized = objectApiName.toLowerCase();
    return ['contactdetail', 'contact_detail', 'contactdetails', 'contact_details'].includes(
      normalized,
    );
  }

  private toPolymorphicApiName(raw: string): string | null {
    if (!raw) return null;
    const normalized = raw.toLowerCase();
    if (normalized === 'account' || normalized === 'accounts') return 'Account';
    if (normalized === 'contact' || normalized === 'contacts') return 'Contact';
    return null;
  }

  private isUuid(value: string): boolean {
    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
      value || '',
    );
  }

  private getDisplayFieldForObjectDefinition(objectDefinition: any): string {
    if (!objectDefinition?.fields) return 'id';
    const hasName = objectDefinition.fields.some((field: any) => field.apiName === 'name');
    if (hasName) return 'name';

    const firstText = objectDefinition.fields.find((field: any) =>
      ['STRING', 'TEXT', 'EMAIL'].includes(String(field.type || '').toUpperCase()),
    );
    return firstText?.apiName || 'id';
  }

  /**
   * Update a field definition
   * Can update metadata (label, description, placeholder, helpText, etc.) safely
   * Cannot update apiName or type if field has existing data (prevent data loss)
   */
  async updateFieldDefinition(
    tenantId: string,
    objectApiName: string,
    fieldApiName: string,
    data: Partial<{
      label: string;
      description: string;
      isRequired: boolean;
      isUnique: boolean;
      defaultValue: string;
      placeholder: string;
      helpText: string;
      displayOrder: number;
      uiMetadata: Record<string, any>;
    }>,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);

    // Get the object definition
    const objectDef = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName });
    
    if (!objectDef) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }

    // Get the field definition
    const field = await knex('field_definitions')
      .where({ objectDefinitionId: objectDef.id, apiName: fieldApiName })
      .first();
    
    if (!field) {
      throw new NotFoundException(`Field ${fieldApiName} not found`);
    }

    // Check if this field has data (count records)
    const tableName = this.getTableName(
      objectDef.apiName,
      objectDef.label,
      objectDef.pluralLabel,
    );
    const recordCount = await knex(tableName).count('* as cnt').first();
    const hasData = recordCount && (recordCount.cnt as number) > 0;

    // Prepare update object
    const updateData: any = {
      updated_at: knex.fn.now(),
    };

    // Always allow these updates
    if (data.label !== undefined) updateData.label = data.label;
    if (data.description !== undefined) updateData.description = data.description;
    if (data.displayOrder !== undefined) updateData.displayOrder = data.displayOrder;
    
    // Merge with existing uiMetadata
    const existingMetadata = field.ui_metadata ? JSON.parse(field.ui_metadata) : {};
    const newMetadata = { ...existingMetadata };
    
    if (data.placeholder !== undefined) newMetadata.placeholder = data.placeholder;
    if (data.helpText !== undefined) newMetadata.helpText = data.helpText;
    if (data.uiMetadata) {
      Object.assign(newMetadata, data.uiMetadata);
    }

    if (Object.keys(newMetadata).length > 0) {
      updateData.ui_metadata = JSON.stringify(newMetadata);
    }

    // Conditional updates based on data existence
    if (data.isRequired !== undefined) {
      if (hasData && data.isRequired && !field.isRequired) {
        throw new Error('Cannot make a field required when data exists. Existing records may have null values.');
      }
      updateData.isRequired = data.isRequired;
    }

    if (data.isUnique !== undefined) {
      if (hasData && data.isUnique && !field.isUnique) {
        throw new Error('Cannot add unique constraint to field with existing data. Existing records may have duplicate values.');
      }
      updateData.isUnique = data.isUnique;
    }

    // Update the field definition
    await knex('field_definitions')
      .where({ id: field.id })
      .update(updateData);

    return knex('field_definitions').where({ id: field.id }).first();
  }

  /**
   * Delete a field definition and clean up dependencies
   * Removes the column from the physical table
   * Removes field references from page layouts
   * CASCADE deletion handles role_field_permissions
   */
  async deleteFieldDefinition(
    tenantId: string,
    objectApiName: string,
    fieldApiName: string,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);

    // Get the object definition
    const objectDef = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName });
    
    if (!objectDef) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }

    // Get the field definition
    const field = await knex('field_definitions')
      .where({ objectDefinitionId: objectDef.id, apiName: fieldApiName })
      .first();
    
    if (!field) {
      throw new NotFoundException(`Field ${fieldApiName} not found`);
    }

    // Prevent deletion of system fields
    const systemFieldNames = ['id', 'tenantId', 'ownerId', 'created_at', 'updated_at', 'createdAt', 'updatedAt'];
    if (systemFieldNames.includes(fieldApiName)) {
      throw new Error(`Cannot delete system field: ${fieldApiName}`);
    }

    // Clean up page layouts - remove field references from layoutConfig
    try {
      const pageLayouts = await knex('page_layouts')
        .where({ object_id: objectDef.id });
      
      for (const layout of pageLayouts) {
        // Handle JSON column that might already be parsed
        let layoutConfig;
        if (layout.layout_config) {
          layoutConfig = typeof layout.layout_config === 'string' 
            ? JSON.parse(layout.layout_config) 
            : layout.layout_config;
        } else {
          layoutConfig = { fields: [] };
        }
        
        // Filter out any field references for this field
        if (layoutConfig.fields) {
          layoutConfig.fields = layoutConfig.fields.filter(
            (f: any) => f.fieldId !== field.id,
          );
        }
        
        // Update the page layout
        await knex('page_layouts')
          .where({ id: layout.id })
          .update({
            layout_config: JSON.stringify(layoutConfig),
            updated_at: knex.fn.now(),
          });
      }
    } catch (error) {
      // If page layouts table doesn't exist or query fails, log but continue
      this.logger.warn(`Could not update page layouts for field deletion: ${error.message}`);
    }

    // Clean up dependsOn references in other fields
    const otherFields = await knex('field_definitions')
      .where({ objectDefinitionId: objectDef.id })
      .whereNot({ id: field.id });
    
    for (const otherField of otherFields) {
      // Handle JSON column that might already be parsed
      let metadata;
      if (otherField.ui_metadata) {
        metadata = typeof otherField.ui_metadata === 'string'
          ? JSON.parse(otherField.ui_metadata)
          : otherField.ui_metadata;
      } else {
        metadata = {};
      }
      
      if (metadata.dependsOn && Array.isArray(metadata.dependsOn)) {
        metadata.dependsOn = metadata.dependsOn.filter(
          (dep: any) => dep !== field.apiName,
        );
        
        await knex('field_definitions')
          .where({ id: otherField.id })
          .update({
            ui_metadata: JSON.stringify(metadata),
            updated_at: knex.fn.now(),
          });
      }
    }

    // Remove the column from the physical table
    const tableName = this.getTableName(
      objectDef.apiName,
      objectDef.label,
      objectDef.pluralLabel,
    );
    const schemaManagementService = new SchemaManagementService();
    
    try {
      await schemaManagementService.removeFieldFromTable(
        knex,
        objectDef.apiName,
        fieldApiName,
        objectDef.label,
        objectDef.pluralLabel,
      );
    } catch (error) {
      this.logger.warn(`Failed to remove column ${fieldApiName} from table ${tableName}: ${error.message}`);
      // Continue with deletion even if column removal fails - field definition must be cleaned up
    }

    // Delete the field definition (CASCADE will delete role_field_permissions)
    await knex('field_definitions').where({ id: field.id }).delete();

    return { success: true };
  }

  async getFieldPermissions(tenantId: string, objectId: string) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Get all field permissions for this object's fields
    const permissions = await knex('role_field_permissions as rfp')
      .join('field_definitions as fd', 'fd.id', 'rfp.fieldDefinitionId')
      .where('fd.objectDefinitionId', objectId)
      .select('rfp.*');
    
    return permissions;
  }

  async updateFieldPermission(
    tenantId: string,
    roleId: string,
    fieldDefinitionId: string,
    canRead: boolean,
    canEdit: boolean,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Check if permission already exists
    const existing = await knex('role_field_permissions')
      .where({ roleId, fieldDefinitionId })
      .first();
    
    if (existing) {
      // Update existing permission
      await knex('role_field_permissions')
        .where({ roleId, fieldDefinitionId })
        .update({
          canRead,
          canEdit,
          updated_at: knex.fn.now(),
        });
    } else {
      // Create new permission
      await knex('role_field_permissions').insert({
        id: knex.raw('(UUID())'),
        roleId,
        fieldDefinitionId,
        canRead,
        canEdit,
        created_at: knex.fn.now(),
        updated_at: knex.fn.now(),
      });
    }
    
    return { success: true };
  }

  async getObjectPermissions(
    tenantId: string,
    objectApiName: string,
    roleId: string,
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Get object definition
    const objectDef = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName });
    
    if (!objectDef) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }
    
    // Get role object permissions
    const permission = await knex('role_object_permissions')
      .where({ roleId, objectDefinitionId: objectDef.id })
      .first();
    
    if (!permission) {
      // Return default permissions (all false)
      return {
        canCreate: false,
        canRead: false,
        canEdit: false,
        canDelete: false,
        canViewAll: false,
        canModifyAll: false,
      };
    }
    
    return {
      canCreate: Boolean(permission.canCreate),
      canRead: Boolean(permission.canRead),
      canEdit: Boolean(permission.canEdit),
      canDelete: Boolean(permission.canDelete),
      canViewAll: Boolean(permission.canViewAll),
      canModifyAll: Boolean(permission.canModifyAll),
    };
  }

  async updateObjectPermissions(
    tenantId: string,
    objectApiName: string,
    data: {
      roleId: string;
      canCreate: boolean;
      canRead: boolean;
      canEdit: boolean;
      canDelete: boolean;
      canViewAll: boolean;
      canModifyAll: boolean;
    },
  ) {
    const resolvedTenantId = await this.tenantDbService.resolveTenantId(tenantId);
    const knex = await this.tenantDbService.getTenantKnexById(resolvedTenantId);
    
    // Get object definition
    const objectDef = await ObjectDefinition.query(knex)
      .findOne({ apiName: objectApiName });
    
    if (!objectDef) {
      throw new NotFoundException(`Object ${objectApiName} not found`);
    }
    
    // Check if permission already exists
    const existing = await knex('role_object_permissions')
      .where({ roleId: data.roleId, objectDefinitionId: objectDef.id })
      .first();
    
    if (existing) {
      // Update existing permission
      await knex('role_object_permissions')
        .where({ roleId: data.roleId, objectDefinitionId: objectDef.id })
        .update({
          canCreate: data.canCreate,
          canRead: data.canRead,
          canEdit: data.canEdit,
          canDelete: data.canDelete,
          canViewAll: data.canViewAll,
          canModifyAll: data.canModifyAll,
          updated_at: knex.fn.now(),
        });
    } else {
      // Create new permission
      await knex('role_object_permissions').insert({
        id: knex.raw('(UUID())'),
        roleId: data.roleId,
        objectDefinitionId: objectDef.id,
        canCreate: data.canCreate,
        canRead: data.canRead,
        canEdit: data.canEdit,
        canDelete: data.canDelete,
        canViewAll: data.canViewAll,
        canModifyAll: data.canModifyAll,
        created_at: knex.fn.now(),
        updated_at: knex.fn.now(),
      });
    }
    
    return { success: true };
  }
}