Product Catalog

class Product {
  final int id;
  final String nombre;
  final String descripcion;
  final String precio;
  final String imagen;
  final int cantidad;
  final String valoracionTotal;
  final String categoria;
  int cantidadCarrito;

  Product({
    required this.id,
    required this.nombre,
    required this.descripcion,
    required this.precio,
    required this.imagen,
    required this.cantidad,
    required this.valoracionTotal,
    required this.categoria,
    this.cantidadCarrito = 1,
  });

  factory Product.fromJson(Map<String, dynamic> json) {
    final id = _asInt(json['id']);
    final nombre = _asString(json['nombre']);
    final descripcion = _asString(json['descripcion']);
    final precio = _asString(json['precio']);
    final imagen = _asString(json['imagen']);
    final cantidad = _asInt(json['cantidad']);
    final valoracionTotal = _asString(json['valoracion_total']);
    final categoria = _asString(json['categoria']);

    if (id == null ||
        nombre == null ||
        descripcion == null ||
        precio == null ||
        imagen == null ||
        cantidad == null ||
        valoracionTotal == null ||
        categoria == null) {
      throw const FormatException('Fallo al cargar producto');
    }

    return Product(
      id: id,
      nombre: nombre,
      descripcion: descripcion,
      precio: precio,
      imagen: imagen,
      cantidad: cantidad,
      valoracionTotal: valoracionTotal,
      categoria: categoria,
    );
  }
}

Future<List<Product>> fetchProductList() async {
  FirebaseBackend.ensureInitialized();
  final snapshot = await FirebaseBackend.products.orderBy('id').get();
  return snapshot.docs
      .map(FirebaseBackend.normalizeSnapshotData)
      .map(_coerceProductPayload)
      .map(Product.fromJson)
      .toList(growable: false);
}

Future<void> addProduct(
  String name,
  String descripcion,
  String precio,
  int stock,
  String categoria,
  XFile imagen,
) async {
  FirebaseBackend.ensureInitialized();
  final productId = await FirebaseBackend.nextNumericId('products');
  final imageUrl = await _uploadProductImage(imagen, productId: productId);
  final now = FieldValue.serverTimestamp();

  await FirebaseBackend.products.add(<String, dynamic>{
    'id': productId,
    'nombre': name.trim(),
    'descripcion': descripcion.trim(),
    'precio': precio.trim(),
    'imagen': imageUrl,
    'cantidad': stock,
    'valoracion_total': '0.0',
    'categoria': categoria.trim(),
    'created_at': now,
    'updated_at': now,
  });
}

Future<void> updateProduct(
  int id, {
  String? name,
  String? descripcion,
  String? precio,
  String? valoracionTotal,
  int? stock,
  String? categoria,
  XFile? imagen,
}) async {
  FirebaseBackend.ensureInitialized();
  final doc = await FirebaseBackend.findByNumericId(FirebaseBackend.products, id);
  final current = doc.data() ?? const <String, dynamic>{};

  String? imageUrl;
  if (imagen != null) {
    imageUrl = await _uploadProductImage(imagen, productId: id);
    final previous = current['imagen'];
    if (previous is String && previous.startsWith('http')) {
      await _tryDeleteStorageUrl(previous);
    }
  }

  final updates = <String, dynamic>{
    if (name != null) 'nombre': name.trim(),
    if (descripcion != null) 'descripcion': descripcion.trim(),
    if (precio != null) 'precio': precio.trim(),
    if (stock != null) 'cantidad': stock,
    if (categoria != null) 'categoria': categoria.trim(),
    if (valoracionTotal != null) 'valoracion_total': valoracionTotal,
    if (imageUrl != null) 'imagen': imageUrl,
    'updated_at': FieldValue.serverTimestamp(),
  };

  if (updates.length == 1) {
    // Only updated_at would be sent; avoid pointless write in callers.
    return;
  }

  await doc.reference.set(updates, SetOptions(merge: true));
}

Future<void> deleteProduct(int id) async {
  FirebaseBackend.ensureInitialized();
  final doc = await FirebaseBackend.findByNumericId(FirebaseBackend.products, id);
  final data = doc.data();
  final imageUrl = data?['imagen'];
  if (imageUrl is String && imageUrl.startsWith('http')) {
    await _tryDeleteStorageUrl(imageUrl);
  }
  await doc.reference.delete();
}

Future<String> _uploadProductImage(
  XFile imagen, {
  required int productId,
}) async {
  final Uint8List bytes = await imagen.readAsBytes();
  final extension = p.extension(imagen.name).toLowerCase();
  final normalizedExt = extension.isEmpty ? '.jpg' : extension;
  final path =
      'products/$productId/${DateTime.now().millisecondsSinceEpoch}$normalizedExt';
  final ref = FirebaseBackend.storage.ref(path);

  final metadata = SettableMetadata(
    contentType: _contentTypeFromExtension(normalizedExt),
  );
  try {
    await ref.putData(bytes, metadata);
    return await ref.getDownloadURL();
  } on FirebaseException catch (e) {
    // Error handling...
  }
}

String _contentTypeFromExtension(String ext) {
  switch (ext) {
    case '.png':
      return 'image/png';
    case '.webp':
      return 'image/webp';
    case '.gif':
      return 'image/gif';
    case '.jpeg':
    case '.jpg':
    default:
      return 'image/jpeg';
  }
}

class ReviewCard extends StatefulWidget {
  final ProductReviews review;

  const ReviewCard({super.key, required this.review});

  @override
  State<ReviewCard> createState() => _ReviewCardState();
}