import { Injectable, inject } from '@angular/core';
import { Firestore, collection, query, where, getDocs, addDoc, updateDoc, deleteDoc, doc } from '@angular/fire/firestore';
import { FirestoreBaseRepository } from '../base/firestore-base.repository';
import { YourEntity } from '@core/domain/models/your-entity.model';

@Injectable({ providedIn: 'root' })
export class YourEntityRepository extends FirestoreBaseRepository<YourEntity> {
  protected collectionName = 'your_collection';
  
  private firestore = inject(Firestore);
  
  /**
   * Convert Firestore document to domain entity
   */
  protected toEntity(data: DocumentData, id: string): YourEntity {
    return {
      id,
      // Map Firestore fields to entity properties
      // Handle snake_case to camelCase conversion
      // Convert Timestamp to Date
      createdAt: this.toDate(data['created_at']),
      updatedAt: this.toDate(data['updated_at']),
      deletedAt: data['deleted_at'] ? this.toDate(data['deleted_at']) : null
    };
  }
  
  /**
   * Convert domain entity to Firestore document
   */
  protected override toDocument(entity: Partial<YourEntity>): DocumentData {
    const doc: DocumentData = {};
    
    // Map entity properties to Firestore fields
    // Handle camelCase to snake_case conversion
    // Convert Date to Timestamp
    
    return doc;
  }
  
  /**
   * Find by Blueprint ID (multi-tenancy pattern)
   */
  async findByBlueprintId(blueprintId: string): Promise<YourEntity[]> {
    return this.executeWithRetry(async () => {
      const q = query(
        collection(this.firestore, this.collectionName),
        where('blueprint_id', '==', blueprintId),
        where('deleted_at', '==', null)
      );
      return this.queryDocuments(q);
    });
  }
  
  // Additional query methods as needed
}

async findByStatus(blueprintId: string, status: string): Promise<YourEntity[]> {
  return this.executeWithRetry(async () => {
    const q = query(
      collection(this.firestore, this.collectionName),
      where('blueprint_id', '==', blueprintId),
      where('status', '==', status),
      where('deleted_at', '==', null),
      orderBy('created_at', 'desc')
    );
    return this.queryDocuments(q);
  });
}

async createBatch(entities: Array<Omit<YourEntity, 'id'>>): Promise<{
  succeeded: YourEntity[];
  failed: Array<{ entity: typeof entities[0]; error: string }>;
}> {
  const succeeded: YourEntity[] = [];
  const failed: Array<{ entity: typeof entities[0]; error: string }> = [];
  
  for (const entity of entities) {
    try {
      const created = await this.create(entity);
      succeeded.push(created);
    } catch (error) {
      failed.push({
        entity,
        error: error instanceof Error ? error.message : 'Unknown error'
      });
    }
  }
  
  return { succeeded, failed };
}

// ✅ CORRECT: Include blueprint_id filter
where('blueprint_id', '==', blueprintId)

// ✅ CORRECT: Exclude soft-deleted items
where('deleted_at', '==', null)

// ❌ WRONG: Global queries without blueprint context
// This violates multi-tenancy security

// Repository - No permission checks
async delete(id: string): Promise<void> {
  return this.executeWithRetry(async () => {
    return this.deleteDocument(id, false); // Soft delete
  });
}

// Security Rules - Permission validation
match /your_collection/{docId} {
  allow delete: if isAuthenticated() 
                && isBlueprintMember(resource.data.blueprint_id)
                && hasPermission(resource.data.blueprint_id, 'entity:delete');
}

describe('YourEntityRepository', () => {
  let repository: YourEntityRepository;
  
  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [YourEntityRepository]
    });
    repository = TestBed.inject(YourEntityRepository);
  });
  
  it('should create entity with timestamps', async () => {
    const entity = { blueprintId: 'test', name: 'Test' };
    const result = await repository.create(entity);
    
    expect(result.id).toBeDefined();
    expect(result.createdAt).toBeInstanceOf(Date);
    expect(result.updatedAt).toBeInstanceOf(Date);
  });
});