import { Injectable, NotFoundException } from '@nestjs/common';
import { TenantDatabaseService } from '../tenant/tenant-database.service';
import { CreatePageLayoutDto, UpdatePageLayoutDto } from './dto/page-layout.dto';

@Injectable()
export class PageLayoutService {
  constructor(private tenantDbService: TenantDatabaseService) {}

  async create(tenantId: string, createDto: CreatePageLayoutDto) {
    const knex = await this.tenantDbService.getTenantKnex(tenantId);
    
    // If this layout is set as default, unset other defaults for the same object
    if (createDto.isDefault) {
      await knex('page_layouts')
        .where({ object_id: createDto.objectId })
        .update({ is_default: false });
    }

    const [id] = await knex('page_layouts').insert({
      name: createDto.name,
      object_id: createDto.objectId,
      is_default: createDto.isDefault || false,
      layout_config: JSON.stringify(createDto.layoutConfig),
      description: createDto.description || null,
    });

    // Get the inserted record
    const result = await knex('page_layouts').where({ id }).first();
    return result;
  }

  async findAll(tenantId: string, objectId?: string) {
    const knex = await this.tenantDbService.getTenantKnex(tenantId);
    
    let query = knex('page_layouts');

    if (objectId) {
      query = query.where({ object_id: objectId });
    }

    const layouts = await query.orderByRaw('is_default DESC, name ASC');
    return layouts;
  }

  async findOne(tenantId: string, id: string) {
    const knex = await this.tenantDbService.getTenantKnex(tenantId);
    
    const layout = await knex('page_layouts').where({ id }).first();

    if (!layout) {
      throw new NotFoundException(`Page layout with ID ${id} not found`);
    }

    return layout;
  }

  async findDefaultByObject(tenantId: string, objectId: string) {
    const knex = await this.tenantDbService.getTenantKnex(tenantId);
    
    const layout = await knex('page_layouts')
      .where({ object_id: objectId, is_default: true })
      .first();

    return layout || null;
  }

  async update(tenantId: string, id: string, updateDto: UpdatePageLayoutDto) {
    const knex = await this.tenantDbService.getTenantKnex(tenantId);
    
    // Check if layout exists
    await this.findOne(tenantId, id);

    // If setting as default, unset other defaults for the same object
    if (updateDto.isDefault) {
      const layout = await this.findOne(tenantId, id);
      await knex('page_layouts')
        .where({ object_id: layout.object_id })
        .whereNot({ id })
        .update({ is_default: false });
    }

    const updates: any = {};

    if (updateDto.name !== undefined) {
      updates.name = updateDto.name;
    }

    if (updateDto.isDefault !== undefined) {
      updates.is_default = updateDto.isDefault;
    }

    if (updateDto.layoutConfig !== undefined) {
      updates.layout_config = JSON.stringify(updateDto.layoutConfig);
    }

    if (updateDto.description !== undefined) {
      updates.description = updateDto.description;
    }

    updates.updated_at = knex.fn.now();

    await knex('page_layouts').where({ id }).update(updates);

    // Get the updated record
    const result = await knex('page_layouts').where({ id }).first();
    return result;
  }

  async remove(tenantId: string, id: string) {
    const knex = await this.tenantDbService.getTenantKnex(tenantId);
    
    await this.findOne(tenantId, id);

    await knex('page_layouts').where({ id }).delete();

    return { message: 'Page layout deleted successfully' };
  }
}