Flutter: desarrollo móvil multiplataforma

# 1. En Linux / macOS (descarga directa del canal estable)
# O clonando el repositorio oficial en una ruta sin permisos de root:
git clone https://github.com/flutter/flutter.git -b stable ~/flutter

# 2. Exportar la ruta en tu ~/.bashrc o ~/.zshrc
export PATH="$HOME/flutter/bin:$PATH"
source ~/.bashrc

# 3. Comprobar la versión instalada
flutter --version

# Diagnóstico completo con salida detallada
flutter doctor -v

# Aceptar todas las licencias del SDK de Android
flutter doctor --android-licenses

# Creación con identificador de organización
flutter create --org com.webcode mi_primera_app

# Ingresar al proyecto
cd mi_primera_app

# Ejecutar en el dispositivo o emulador conectado
flutter run

import 'package:flutter/material.dart';

void main() {
  // Asegura que los canales binarios del sistema estén listos
  // (Obligatorio si inicializas plugins como Firebase, SharedPreferences o SQLite antes de runApp)
  WidgetsFlutterBinding.ensureInitialized();

  runApp(const MiAplicacion());
}

class MiAplicacion extends StatelessWidget {
  const MiAplicacion({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Clínica Móvil',
      debugShowCheckedModeBanner: false,
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: const Color(0xFF02569B)),
        useMaterial3: true,
      ),
      home: const Scaffold(
        body: Center(child: Text('Bienvenido al sistema')),
      ),
    );
  }
}

Future<void> _cargarDatosServidor() async {
  final resultado = await servicioApi.obtenerPerfil();

  // Guarda de seguridad: verifica si el widget sigue vivo en pantalla
  if (!mounted) return;

  setState(() {
    _perfil = resultado;
    _cargando = false;
  });
}

AppBar(
  // 1. Icono de navegación izquierdo (Drawer o flecha de retorno)
  leading: IconButton(
    icon: const Icon(Icons.menu),
    tooltip: 'Abrir menú',
    onPressed: () => Scaffold.of(context).openDrawer(),
  ),

  // 2. Título principal centrado o alineado al inicio
  title: const Text('Gestión de Citas'),
  centerTitle: false,

  // 3. Botones de acción en la esquina superior derecha
  actions: [
    IconButton(
      icon: const Icon(Icons.search),
      tooltip: 'Buscar paciente',
      onPressed: () {},
    ),
    IconButton(
      icon: const Icon(Icons.filter_list),
      tooltip: 'Filtrar',
      onPressed: () {},
    ),
  ],

  // 4. Parámetros visuales en Material 3
  elevation: 0,
  scrolledUnderElevation: 3.0, // Elevación tonal automática al hacer scroll
  backgroundColor: Theme.of(context).colorScheme.surface,
);

Drawer(
  child: ListView(
    padding: EdgeInsets.zero,
    children: [
      // Encabezado con información del usuario autenticado
      UserAccountsDrawerHeader(
        decoration: BoxDecoration(
          color: Theme.of(context).colorScheme.primary,
        ),
        currentAccountPicture: const CircleAvatar(
          backgroundColor: Colors.white,
          child: Icon(Icons.person, size: 36, color: Color(0xFF02569B)),
        ),
        accountName: const Text('Dr. Carlos Mendoza'),
        accountEmail: const Text('carlos.mendoza@clinica.pe'),
      ),

      // Opciones de navegación
      ListTile(
        leading: const Icon(Icons.calendar_today),
        title: const Text('Citas de Hoy'),
        onTap: () {
          // 1. Cerrar el drawer primero
          Navigator.pop(context);
          // 2. Navegar a la pantalla deseada
        },
      ),
      ListTile(
        leading: const Icon(Icons.people_outline),
        title: const Text('Directorio de Pacientes'),
        onTap: () => Navigator.pop(context),
      ),
      const Divider(),
      ListTile(
        leading: const Icon(Icons.logout, color: Colors.redAccent),
        title: const Text('Cerrar Sesión', style: TextStyle(color: Colors.redAccent)),
        onTap: () => Navigator.pop(context),
      ),
    ],
  ),
);

Scaffold(
  // Ubicaciones: endFloat (default), centerFloat, centerDocked, endDocked
  floatingActionButtonLocation: FloatingActionButtonLocation.endFloat,
  floatingActionButton: FloatingActionButton.extended(
    onPressed: () => registrarNuevaCita(),
    icon: const Icon(Icons.add),
    label: const Text('Nueva Cita'),
  ),
  body: const Center(child: Text('Contenido principal')),
);

void mostrarMensajeExito(BuildContext context, String mensaje) {
  // 1. Ocultar SnackBar previo si estuviese visible
  ScaffoldMessenger.of(context).hideCurrentSnackBar();

  // 2. Disparar el nuevo aviso configurado
  ScaffoldMessenger.of(context).showSnackBar(
    SnackBar(
      content: Row(
        children: [
          const Icon(Icons.check_circle_outline, color: Colors.white),
          const SizedBox(width: 10),
          Expanded(child: Text(mensaje)),
        ],
      ),
      duration: const Duration(seconds: 3),
      behavior: SnackBarBehavior.floating, // Flota sobre la pantalla sin pegarse al borde
      shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(10)),
      action: SnackBarAction(
        label: 'DESHACER',
        textColor: Colors.amberAccent,
        onPressed: () {
          // Lógica de reversión inmediata
        },
      ),
    ),
  );
}

void mostrarOpciones(BuildContext context) {
  showModalBottomSheet(
    context: context,
    showDragHandle: true, // Tirador visual nativo de arrastre en Material 3
    shape: const RoundedRectangleBorder(
      borderRadius: BorderRadius.vertical(top: Radius.circular(20)),
    ),
    builder: (BuildContext ctx) {
      return Padding(
        padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
        child: Column(
          mainAxisSize: MainAxisSize.min, // Ocupa solo la altura requerida
          children: [
            ListTile(
              leading: const Icon(Icons.photo_camera),
              title: const Text('Tomar fotografía'),
              onTap: () => Navigator.pop(ctx, 'camara'),
            ),
            ListTile(
              leading: const Icon(Icons.photo_library),
              title: const Text('Elegir de la galería'),
              onTap: () => Navigator.pop(ctx, 'galeria'),
            ),
          ],
        ),
      );
    },
  );
}

Row(
  mainAxisAlignment: MainAxisAlignment.spaceBetween,
  crossAxisAlignment: CrossAxisAlignment.center,
  // MainAxisSize.min hace que el Row o Column solo ocupe lo necesario
  mainAxisSize: MainAxisSize.max,
  children: const [
    Icon(Icons.access_time, color: Colors.blueGrey),
    Text('09:30 AM', style: TextStyle(fontWeight: FontWeight.bold)),
    Chip(label: Text('Confirmada')),
  ],
);

Row(
  children: [
    Expanded(flex: 3, child: Container(color: Colors.blueAccent, height: 40)),
    Expanded(flex: 1, child: Container(color: Colors.amberAccent, height: 40)),
  ],
);

// Ejemplo: Tags dinámicos que se adaptan a múltiples líneas sin desbordar
Wrap(
  spacing: 8.0, // Separación horizontal entre chips
  runSpacing: 4.0, // Separación vertical entre líneas consecutivas
  children: const [
    Chip(label: Text('Medicina General')),
    Chip(label: Text('Cardiología')),
    Chip(label: Text('Pediatría')),
    Chip(label: Text('Dermatología')),
    Chip(label: Text('Traumatología')),
  ],
);

// Tarjeta de perfil médico con avatar e indicador de estado "En línea"
SizedBox(
  width: 90,
  height: 90,
  child: Stack(
    clipBehavior: Clip.none, // Permite que elementos sobresalgan del marco
    children: [
      // 1. Imagen base circular
      const CircleAvatar(
        radius: 42,
        backgroundImage: NetworkImage('https://webcode.net.pe/medico1.jpg'),
      ),

      // 2. Insignia flotante anclada a la esquina inferior derecha
      Positioned(
        bottom: 2,
        right: 2,
        child: Container(
          width: 18,
          height: 18,
          decoration: BoxDecoration(
            color: Colors.greenAccent[700],
            shape: BoxShape.circle,
            border: Border.all(color: Colors.white, width: 2.5),
          ),
        ),
      ),
    ],
  ),
);

import 'package:flutter/material.dart';

class DirectorioClinicoAdaptativo extends StatelessWidget {
  const DirectorioClinicoAdaptativo({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Agenda Médica')),
      body: OrientationBuilder(
        builder: (BuildContext context, Orientation orientation) {
          // Si el usuario sostiene el teléfono en vertical: 1 sola columna
          if (orientation == Orientation.portrait) {
            return const ListaMedicosVertical();
          }

          // Si el usuario gira el teléfono en horizontal: 2 columnas maestro-detalle
          return const Row(
            children: [
              Expanded(flex: 2, child: ListaMedicosVertical()),
              VerticalDivider(width: 1),
              Expanded(flex: 3, child: FichaDetalleConsulta()),
            ],
          );
        },
      ),
    );
  }
}

Container(
  margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
  padding: const EdgeInsets.all(20),
  decoration: BoxDecoration(
    // 1. Gradiente de fondo con dos paradas de color
    gradient: const LinearGradient(
      colors: [Color(0xFF02569B), Color(0xFF0175C2)],
      begin: Alignment.topLeft,
      end: Alignment.bottomRight,
    ),

    // 2. Esquinas redondeadas
    borderRadius: BorderRadius.circular(16),

    // 3. Borde perimetral sutil
    border: Border.all(color: Colors.white.withOpacity(0.2), width: 1.5),

    // 4. Sombras proyectadas en elevación
    boxShadow: [
      BoxShadow(
        color: const Color(0xFF02569B).withOpacity(0.35),
        offset: const Offset(0, 6),
        blurRadius: 12,
        spreadRadius: 1,
      ),
    ],
  ),
  child: const Text(
    'Tarjeta Promocional Clínica 2026',
    style: TextStyle(color: Colors.white, fontWeight: FontWeight.bold),
  ),
);

ConstrainedBox(
  constraints: const BoxConstraints(
    minWidth: 140,
    maxWidth: 280,
    minHeight: 48,
  ),
  child: ElevatedButton(
    onPressed: () {},
    child: const Text('Botón con tamaño inteligente'),
  ),
);

Card(
  elevation: 2,
  // clipBehavior recorta a los hijos para respetar el borde circular
  clipBehavior: Clip.antiAlias,
  shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(14)),
  child: Column(
    crossAxisAlignment: CrossAxisAlignment.start,
    children: [
      Image.network(
        'https://webcode.net.pe/sala_cirugia.jpg',
        height: 140,
        width: double.infinity,
        fit: BoxFit.cover,
      ),
      const Padding(
        padding: EdgeInsets.all(12),
        child: Text(
          'Quirófano Central 01',
          style: TextStyle(fontWeight: FontWeight.bold, fontSize: 16),
        ),
      ),
    ],
  ),
);

class Medico {
  final int id;
  final String nombre;
  final String especialidad;
  final bool activo;

  const Medico({required this.id, required this.nombre, required this.especialidad, required this.activo});
}

// Renderizado perezoso de 10,000 médicos con consumo constante de RAM
ListView.builder(
  itemCount: listaMedicos.length,
  itemBuilder: (BuildContext context, int index) {
    final medico = listaMedicos[index];
    return ListTile(
      leading: CircleAvatar(
        child: Text('${medico.id}'),
      ),
      title: Text(medico.nombre, style: const TextStyle(fontWeight: FontWeight.bold)),
      subtitle: Text(medico.especialidad),
      trailing: Icon(
        medico.activo ? Icons.check_circle : Icons.cancel,
        color: medico.activo ? Colors.green : Colors.grey,
      ),
      onTap: () {
        // Navegar al perfil del médico
      },
    );
  },
);

ListView.separated(
  itemCount: pacientes.length,
  separatorBuilder: (context, index) => const Divider(
    height: 1,
    indent: 16,
    endIndent: 16,
  ),
  itemBuilder: (context, index) {
    return ListTile(
      title: Text(pacientes[index].nombreCompleto),
      subtitle: Text('DNI: ${pacientes[index].documento}'),
    );
  },
);

GridView.builder(
  padding: const EdgeInsets.all(12),
  itemCount: especialidades.length,
  gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(
    crossAxisCount: 2,        // 2 columnas exactas
    crossAxisSpacing: 10,     // Separación horizontal entre columnas
    mainAxisSpacing: 10,      // Separación vertical entre filas
    childAspectRatio: 1.2,    // Proporción ancho / alto de cada celda
  ),
  itemBuilder: (context, index) {
    final esp = especialidades[index];
    return Card(
      elevation: 2,
      child: Center(
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            const Icon(Icons.local_hospital, size: 32, color: Color(0xFF02569B)),
            const SizedBox(height: 8),
            Text(esp.nombre, style: const TextStyle(fontWeight: FontWeight.bold)),
          ],
        ),
      ),
    );
  },
);

FilledButton.icon(
  // Si onPressed es null, Flutter deshabilita el botón automáticamente
  onPressed: formularioValido ? () => confirmarCita() : null,
  icon: const Icon(Icons.check_circle_outline),
  label: const Text('Confirmar Agendamiento'),
  style: FilledButton.styleFrom(
    backgroundColor: const Color(0xFF02569B),
    foregroundColor: Colors.white,
    padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 14),
    shape: RoundedRectangleBorder(
      borderRadius: BorderRadius.circular(12),
    ),
    textStyle: const TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
  ),
);

class FormularioPacienteState extends State<FormularioPaciente> {
  // 1. Llave global que referencia el estado del formulario
  final _formKey = GlobalKey<FormState>();

  // 2. Controladores de texto para leer y mutar valores
  late final TextEditingController _nombreCtrl;
  late final TextEditingController _dniCtrl;
  late final TextEditingController _emailCtrl;

  @override
  void initState() {
    super.initState();
    _nombreCtrl = TextEditingController();
    _dniCtrl = TextEditingController();
    _emailCtrl = TextEditingController();
  }

  @override
  void dispose() {
    // 3. Regla de oro: liberar siempre los controladores en dispose
    _nombreCtrl.dispose();
    _dniCtrl.dispose();
    _emailCtrl.dispose();
    super.dispose();
  }

  void _enviarFormulario() {
    // 4. validate() dispara todas las funciones validator del árbol
    if (_formKey.currentState!.validate()) {
      // Si todos los campos son válidos, procedemos al guardado
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(content: Text('Guardando paciente en base de datos...')),
      );
    }
  }

  @override
  Widget build(BuildContext context) {
    return Form(
      key: _formKey,
      child: Column(
        children: [
          // Campos TextFormField integrados...
        ],
      ),
    );
  }
}

// 1. Campo Nombre (no vacío)
TextFormField(
  controller: _nombreCtrl,
  decoration: const InputDecoration(
    labelText: 'Nombres y Apellidos *',
    prefixIcon: Icon(Icons.person),
    border: OutlineInputBorder(),
  ),
  validator: (valor) {
    if (valor == null || valor.trim().isEmpty) {
      return 'El nombre es obligatorio';
    }
    return null;
  },
),

const SizedBox(height: 16),

// 2. Campo DNI (Exactamente 8 dígitos numéricos peruanos)
TextFormField(
  controller: _dniCtrl,
  keyboardType: TextInputType.number,
  decoration: const InputDecoration(
    labelText: 'Documento Nacional de Identidad (DNI) *',
    prefixIcon: Icon(Icons.badge),
    border: OutlineInputBorder(),
  ),
  validator: (valor) {
    if (valor == null || valor.trim().isEmpty) {
      return 'Ingrese el número de DNI';
    }
    final dniRegex = RegExp(r'^\d{8}$');
    if (!dniRegex.hasMatch(valor.trim())) {
      return 'El DNI debe contener exactamente 8 dígitos numéricos';
    }
    return null;
  },
),

const SizedBox(height: 16),

// 3. Campo Correo Electrónico
TextFormField(
  controller: _emailCtrl,
  keyboardType: TextInputType.emailAddress,
  decoration: const InputDecoration(
    labelText: 'Correo Electrónico *',
    prefixIcon: Icon(Icons.email),
    border: OutlineInputBorder(),
  ),
  validator: (valor) {
    if (valor == null || valor.trim().isEmpty) {
      return 'Ingrese un correo electrónico';
    }
    final emailRegex = RegExp(r'^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$');
    if (!emailRegex.hasMatch(valor.trim())) {
      return 'Formato de correo no válido';
    }
    return null;
  },
),

// Declarar los nodos de foco en la clase State
final _nodoDni = FocusNode();
final _nodoEmail = FocusNode();

// En el primer campo:
TextFormField(
  controller: _nombreCtrl,
  textInputAction: TextInputAction.next, // Muestra botón "Siguiente" en el teclado
  onFieldSubmitted: (_) {
    // Salta automáticamente al campo DNI
    FocusScope.of(context).requestFocus(_nodoDni);
  },
);

// En el segundo campo:
TextFormField(
  controller: _dniCtrl,
  focusNode: _nodoDni,
  textInputAction: TextInputAction.next,
  onFieldSubmitted: (_) {
    FocusScope.of(context).requestFocus(_nodoEmail);
  },
);

// Al tocar cualquier área vacía, el teclado se retrae suavemente
GestureDetector(
  onTap: () => FocusScope.of(context).unfocus(),
  child: Scaffold(
    appBar: AppBar(title: const Text('Registro')),
    body: SingleChildScrollView(
      padding: const EdgeInsets.all(16),
      child: Form(
        key: _formKey,
        child: Column(
          children: [
            // Campos de formulario...
          ],
        ),
      ),
    ),
  ),
);

Future<void> confirmarCancelacionCita(BuildContext context, int citaId) async {
  // 1. showDialog retorna un Future con el valor devuelto en Navigator.pop
  final bool? confirmar = await showDialog<bool>(
    context: context,
    // barrierDismissible: false impide cerrar el diálogo pulsando fuera
    barrierDismissible: false,
    builder: (BuildContext ctx) {
      return AlertDialog(
        icon: const Icon(Icons.warning_amber_rounded, color: Colors.redAccent, size: 36),
        title: const Text('¿Cancelar Cita Médica?'),
        content: Text('Esta acción liberará el turno #$citaId para otro paciente.'),
        actions: [
          TextButton(
            onPressed: () => Navigator.pop(ctx, false), // Retorna false
            child: const Text('Conservar Cita'),
          ),
          FilledButton(
            style: FilledButton.styleFrom(backgroundColor: Colors.redAccent),
            onPressed: () => Navigator.pop(ctx, true), // Retorna true
            child: const Text('Sí, Cancelar'),
          ),
        ],
      );
    },
  );

  // 2. Evaluamos la decisión del usuario de forma asíncrona
  if (confirmar == true && context.mounted) {
    ScaffoldMessenger.of(context).showSnackBar(
      const SnackBar(content: Text('La cita médica ha sido cancelada')),
    );
  }
}

Future<String?> seleccionarMetodoPago(BuildContext context) async {
  return await showDialog<String>(
    context: context,
    builder: (BuildContext ctx) {
      return SimpleDialog(
        title: const Text('Seleccione método de pago'),
        children: [
          SimpleDialogOption(
            onPressed: () => Navigator.pop(ctx, 'EFECTIVO'),
            child: const ListTile(leading: Icon(Icons.money), title: Text('Efectivo en caja')),
          ),
          SimpleDialogOption(
            onPressed: () => Navigator.pop(ctx, 'TARJETA'),
            child: const ListTile(leading: Icon(Icons.credit_card), title: Text('Tarjeta Débito/Crédito')),
          ),
          SimpleDialogOption(
            onPressed: () => Navigator.pop(ctx, 'YAPE_PLIN'),
            child: const ListTile(leading: Icon(Icons.qr_code), title: Text('Billetera Digital (Yape / Plin)')),
          ),
        ],
      );
    },
  );
}

class PantallaCitasTabs extends StatelessWidget {
  const PantallaCitasTabs({super.key});

  @override
  Widget build(BuildContext context) {
    // DefaultTabController administra el estado de las 3 pestañas automáticamente
    return DefaultTabController(
      length: 3,
      child: Scaffold(
        appBar: AppBar(
          title: const Text('Consultas Médicas'),
          bottom: const TabBar(
            indicatorSize: TabBarIndicatorSize.tab,
            tabs: [
              Tab(icon: Icon(Icons.schedule), text: 'Pendientes'),
              Tab(icon: Icon(Icons.check_circle_outline), text: 'Atendidas'),
              Tab(icon: Icon(Icons.highlight_off), text: 'Canceladas'),
            ],
          ),
        ),
        body: const TabBarView(
          children: [
            VistaCitasPendientes(),
            VistaCitasAtendidas(),
            VistaCitasCanceladas(),
          ],
        ),
      ),
    );
  }
}

class VistaCitasPendientes extends StatefulWidget {
  const VistaCitasPendientes({super.key});

  @override
  State<VistaCitasPendientes> createState() => _VistaCitasPendientesState();
}

// Aplicamos el mixin AutomaticKeepAliveClientMixin en la clase State
class _VistaCitasPendientesState extends State<VistaCitasPendientes>
    with AutomaticKeepAliveClientMixin {

  // 1. Declarar wantKeepAlive en true para preservar el estado
  @override
  bool get wantKeepAlive => true;

  @override
  Widget build(BuildContext context) {
    // 2. Es obligatorio invocar super.build(context) como primera línea
    super.build(context);

    return ListView.builder(
      itemCount: 100,
      itemBuilder: (context, i) => ListTile(title: Text('Cita #$i (Preservada)')),
    );
  }
}

// Comprobar si el usuario puede retroceder en la pila actual
if (Navigator.canPop(context)) {
  Navigator.pop(context);
}

import 'package:flutter/material.dart';

// Pantalla Origen (Lista de Médicos)
class PantallaMedicos extends StatelessWidget {
  const PantallaMedicos({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Directorio Médico')),
      body: Center(
        child: FilledButton.icon(
          icon: const Icon(Icons.person),
          label: const Text('Ver Ficha del Dr. Morales'),
          onPressed: () {
            // Navegamos pasando parámetros tipados directamente al constructor
            Navigator.push(
              context,
              MaterialPageRoute(
                builder: (BuildContext ctx) => const PantallaDetalleMedico(
                  medicoId: 104,
                  nombre: 'Dr. Roberto Morales',
                  especialidad: 'Cardiología',
                ),
              ),
            );
          },
        ),
      ),
    );
  }
}

// Pantalla Destino que solicita una acción y retorna un booleano
class PantallaConfirmarTurno extends StatelessWidget {
  final int turnoId;
  const PantallaConfirmarTurno({super.key, required this.turnoId});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Confirmar Turno #$turnoId')),
      body: Center(
        child: Row(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            OutlinedButton(
              onPressed: () => Navigator.pop(context, false), // Retorna false
              child: const Text('Rechazar'),
            ),
            const SizedBox(width: 16),
            FilledButton(
              onPressed: () => Navigator.pop(context, true), // Retorna true
              child: const Text('Aceptar Turno'),
            ),
          ],
        ),
      ),
    );
  }
}

// Invocación asíncrona desde la pantalla principal
Future<void> solicitarAprobacion(BuildContext context, int turnoId) async {
  // 1. Esperamos la respuesta fuertemente tipada como bool?
  final bool? resultado = await Navigator.push<bool>(
    context,
    MaterialPageRoute(
      builder: (context) => PantallaConfirmarTurno(turnoId: turnoId),
    ),
  );

  // 2. Regla de oro: verificar context.mounted tras cualquier pausa asíncrona
  if (!context.mounted) return;

  if (resultado == true) {
    ScaffoldMessenger.of(context).showSnackBar(
      const SnackBar(content: Text('¡Turno médico confirmado exitosamente!')),
    );
  }
}

// Cerrar sesión y vaciar completamente la pila de rutas
void cerrarSesion(BuildContext context) {
  Navigator.pushAndRemoveUntil(
    context,
    MaterialPageRoute(builder: (context) => const PantallaLogin()),
    (Route<dynamic> route) => false, // El predicado false destruye todo el historial previo
  );
}

class FormularioPacienteConGuardia extends StatefulWidget {
  const FormularioPacienteConGuardia({super.key});

  @override
  State<FormularioPacienteConGuardia> createState() => _FormularioPacienteConGuardiaState();
}

class _FormularioPacienteConGuardiaState extends State<FormularioPacienteConGuardia> {
  bool _hayCambiosSinGuardar = true;

  Future<bool> _mostrarDialogoConfirmacion() async {
    final bool? abandonar = await showDialog<bool>(
      context: context,
      builder: (ctx) => AlertDialog(
        title: const Text('¿Descartar cambios?'),
        content: const Text('Tienes datos ingresados que se perderán si sales ahora.'),
        actions: [
          TextButton(
            onPressed: () => Navigator.pop(ctx, false),
            child: const Text('Continuar editando'),
          ),
          FilledButton(
            onPressed: () => Navigator.pop(ctx, true),
            child: const Text('Descartar y salir'),
          ),
        ],
      ),
    );
    return abandonar ?? false;
  }

  @override
  Widget build(BuildContext context) {
    return PopScope(
      // Si no hay cambios sin guardar, permitimos el pop directo (canPop: true).
      // Si hay cambios, bloqueamos el pop automático (canPop: false) para disparar el diálogo.
      canPop: !_hayCambiosSinGuardar,
      onPopInvokedWithResult: (bool didPop, dynamic result) async {
        // Si el pop ya se ejecutó con éxito por el sistema, no hacemos nada
        if (didPop) return;

        // Si fue bloqueado, consultamos al usuario
        final bool seguro = await _mostrarDialogoConfirmacion();
        if (seguro && context.mounted) {
          // Desactivamos la guardia y ejecutamos el pop manualmente
          setState(() => _hayCambiosSinGuardar = false);
          Navigator.pop(context);
        }
      },
      child: Scaffold(
        appBar: AppBar(title: const Text('Registro Clínico')),
        body: const Center(
          child: Text('Formulario con cambios pendientes de guardar...'),
        ),
      ),
    );
  }
}

// EN PANTALLA A: Avatar pequeño en la lista
ListTile(
  leading: Hero(
    tag: 'avatar-dr-morales', // Identificador único compartido
    child: CircleAvatar(
      radius: 20,
      backgroundColor: Colors.teal,
      child: Text('RM', style: TextStyle(color: Colors.white)),
    ),
  ),
  title: const Text('Dr. Roberto Morales'),
  subtitle: const Text('Cardiología'),
  onTap: () {
    // Navegación con animación personalizada de deslizamiento suave (Slide)
    Navigator.push(
      context,
      PageRouteBuilder(
        transitionDuration: const Duration(milliseconds: 500),
        pageBuilder: (context, animacion, animacionSecundaria) {
          return const PantallaFichaDetalleMedico();
        },
        transitionsBuilder: (context, animacion, animacionSecundaria, child) {
          // Curva de aceleración natural
          final curva = CurvedAnimation(parent: animacion, curve: Curves.easeInOutCubic);
          return SlideTransition(
            position: Tween<Offset>(begin: const Offset(0.0, 0.1), end: Offset.zero).animate(curva),
            child: FadeTransition(opacity: curva, child: child),
          );
        },
      ),
    );
  },
);

// EN PANTALLA B: Cabecera expandida en la vista de detalle
class PantallaFichaDetalleMedico extends StatelessWidget {
  const PantallaFichaDetalleMedico({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Ficha Médica')),
      body: Center(
        child: Column(
          children: [
            const SizedBox(height: 24),
            // El mismo tag hace que el avatar "vuele" desde la lista hasta aquí
            Hero(
              tag: 'avatar-dr-morales',
              child: CircleAvatar(
                radius: 60,
                backgroundColor: Colors.teal,
                child: Text('RM', style: TextStyle(fontSize: 36, color: Colors.white)),
              ),
            ),
            const SizedBox(height: 16),
            const Text('Dr. Roberto Morales', style: TextStyle(fontSize: 22, fontWeight: FontWeight.bold)),
          ],
        ),
      ),
    );
  }
}

# Instalación de la versión oficial en pubspec.yaml
flutter pub add go_router

import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';

void main() {
  runApp(const MiAppClinica());
}

// 1. Instanciamos el enrutador con su configuración de rutas
final GoRouter _appRouter = GoRouter(
  initialLocation: '/',
  routes: [
    GoRoute(
      path: '/',
      name: 'inicio',
      builder: (BuildContext context, GoRouterState state) => const PantallaInicio(),
      routes: [
        // Sub-ruta anidada: la URL resultante será '/pacientes'
        GoRoute(
          path: 'pacientes',
          name: 'lista-pacientes',
          builder: (context, state) => const PantallaPacientes(),
        ),
      ],
    ),
  ],
);

// 2. Conectamos GoRouter a la raíz de la aplicación
class MiAppClinica extends StatelessWidget {
  const MiAppClinica({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp.router(
      title: 'Clínica San Juan',
      theme: ThemeData(useMaterial3: true, colorSchemeSeed: Colors.teal),
      routerConfig: _appRouter,
    );
  }
}

final GoRouter _routerConParametros = GoRouter(
  routes: [
    GoRoute(
      path: '/paciente/:id',
      name: 'detalle-paciente',
      builder: (BuildContext context, GoRouterState state) {
        // 1. Parámetro de ruta obligatorio (Path Parameter)
        final String pacienteId = state.pathParameters['id'] ?? '0';

        // 2. Parámetro de consulta opcional (Query Parameter desde URI)
        final String? pestanaInicial = state.uri.queryParameters['tab'];

        return PantallaDetallePaciente(
          id: int.parse(pacienteId),
          tabActiva: pestanaInicial ?? 'historial',
        );
      },
    ),
  ],
);

// Navegación nombrada con parámetros tipados
void verDetallePaciente(BuildContext context, int id) {
  context.goNamed(
    'detalle-paciente',
    pathParameters: {'id': id.toString()},
    queryParameters: {'tab': 'recetas'},
  );
}

// Cerrar la vista actual o retroceder
void volverAtras(BuildContext context) {
  if (context.canPop()) {
    context.pop();
  }
}

bool usuarioAutenticado = false; // Estado global o servicio de auth

final GoRouter _routerSeguro = GoRouter(
  initialLocation: '/',
  redirect: (BuildContext context, GoRouterState state) {
    final bool enPantallaLogin = state.matchedLocation == '/login';

    // 1. Si no está autenticado y no está en login, redirigir a /login
    if (!usuarioAutenticado && !enPantallaLogin) {
      return '/login';
    }

    // 2. Si ya está autenticado e intenta ir a /login, redirigir al panel principal
    if (usuarioAutenticado && enPantallaLogin) {
      return '/';
    }

    // 3. Retornar null significa "permitir el paso sin redirección"
    return null;
  },
  routes: [
    GoRoute(path: '/login', builder: (ctx, state) => const PantallaLogin()),
    GoRoute(path: '/', builder: (ctx, state) => const PantallaDashboard()),
  ],
  // 4. Gestión centralizada de errores y rutas no encontradas (404)
  errorBuilder: (context, state) => Scaffold(
    appBar: AppBar(title: const Text('Página no encontrada')),
    body: Center(
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          const Icon(Icons.error_outline, size: 64, color: Colors.redAccent),
          const SizedBox(height: 16),
          Text('Error 404: Ruta desconocida (${state.matchedLocation})'),
          const SizedBox(height: 24),
          FilledButton(
            onPressed: () => context.go('/'),
            child: const Text('Volver al inicio'),
          ),
        ],
      ),
    ),
  ),
);

class PantallaPrincipalM3 extends StatefulWidget {
  const PantallaPrincipalM3({super.key});

  @override
  State<PantallaPrincipalM3> createState() => _PantallaPrincipalM3State();
}

class _PantallaPrincipalM3State extends State<PantallaPrincipalM3> {
  int _indiceActual = 0;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      bottomNavigationBar: NavigationBar(
        selectedIndex: _indiceActual,
        onDestinationSelected: (int nuevoIndice) {
          setState(() => _indiceActual = nuevoIndice);
        },
        destinations: const [
          NavigationDestination(
            icon: Icon(Icons.calendar_month_outlined),
            selectedIcon: Icon(Icons.calendar_month),
            label: 'Citas',
          ),
          NavigationDestination(
            icon: Icon(Icons.people_outline),
            selectedIcon: Icon(Icons.people),
            label: 'Pacientes',
          ),
          NavigationDestination(
            icon: Icon(Icons.medication_outlined),
            selectedIcon: Icon(Icons.medication),
            label: 'Recetas',
          ),
        ],
      ),
      body: Center(
        child: Text('Vista seleccionada: $_indiceActual'),
      ),
    );
  }
}

Drawer construirMenuLateral(BuildContext context, int indice, ValueChanged<int> onSelect) {
  return Drawer(
    child: NavigationDrawer(
      selectedIndex: indice,
      onDestinationSelected: (idx) {
        onSelect(idx);
        Navigator.pop(context); // Cierra el drawer al seleccionar
      },
      children: const [
        Padding(
          padding: EdgeInsets.fromLTRB(28, 16, 16, 10),
          child: Text('Portal Médico San Juan', style: TextStyle(fontWeight: FontWeight.bold, fontSize: 18)),
        ),
        NavigationDrawerDestination(
          icon: Icon(Icons.dashboard_outlined),
          selectedIcon: Icon(Icons.dashboard),
          label: Text('Panel General'),
        ),
        NavigationDrawerDestination(
          icon: Icon(Icons.medical_services_outlined),
          selectedIcon: Icon(Icons.medical_services),
          label: Text('Consultas Activas'),
        ),
        Divider(indent: 16, endIndent: 16),
        NavigationDrawerDestination(
          icon: Icon(Icons.settings_outlined),
          selectedIcon: Icon(Icons.settings),
          label: Text('Ajustes y Perfil'),
        ),
      ],
    ),
  );
}

// ANTIPATRÓN: Destruye y recrea la vista en cada pulsación
body: _vistas[_indiceActual],

class PantallaConEstadoPreservado extends StatefulWidget {
  const PantallaConEstadoPreservado({super.key});

  @override
  State<PantallaConEstadoPreservado> createState() => _PantallaConEstadoPreservadoState();
}

class _PantallaConEstadoPreservadoState extends State<PantallaConEstadoPreservado> {
  int _indice = 0;

  // Las vistas hijas se conservarán intactas en memoria
  final List<Widget> _paginas = const [
    VistaListaCitas(),
    VistaDirectorioPacientes(),
    VistaHistorialRecetas(),
  ];

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: IndexedStack(
        index: _indice,
        children: _paginas,
      ),
      bottomNavigationBar: NavigationBar(
        selectedIndex: _indice,
        onDestinationSelected: (i) => setState(() => _indice = i),
        destinations: const [
          NavigationDestination(icon: Icon(Icons.event), label: 'Citas'),
          NavigationDestination(icon: Icon(Icons.people), label: 'Pacientes'),
          NavigationDestination(icon: Icon(Icons.receipt_long), label: 'Recetas'),
        ],
      ),
    );
  }
}

final GoRouter _routerConPestanas = GoRouter(
  initialLocation: '/citas',
  routes: [
    StatefulShellRoute.indexedStack(
      builder: (BuildContext context, GoRouterState state, StatefulNavigationShell navigationShell) {
        // navigationShell contiene la vista activa y gestiona el cambio de ramas
        return Scaffold(
          body: navigationShell,
          bottomNavigationBar: NavigationBar(
            selectedIndex: navigationShell.currentIndex,
            onDestinationSelected: (int index) {
              // Navegación con opción de regresar a la raíz de la pestaña si ya está activa
              navigationShell.goBranch(
                index,
                initialLocation: index == navigationShell.currentIndex,
              );
            },
            destinations: const [
              NavigationDestination(icon: Icon(Icons.calendar_today), label: 'Citas'),
              NavigationDestination(icon: Icon(Icons.group), label: 'Pacientes'),
            ],
          ),
        );
      },
      branches: [
        // Rama 1: Citas
        StatefulShellBranch(
          routes: [
            GoRoute(
              path: '/citas',
              builder: (context, state) => const VistaListaCitas(),
            ),
          ],
        ),
        // Rama 2: Pacientes (con su propio sub-árbol de detalle)
        StatefulShellBranch(
          routes: [
            GoRoute(
              path: '/pacientes',
              builder: (context, state) => const VistaDirectorioPacientes(),
              routes: [
                GoRoute(
                  path: 'detalle/:id',
                  builder: (context, state) => VistaFichaPaciente(id: state.pathParameters['id']!),
                ),
              ],
            ),
          ],
        ),
      ],
    ),
  ],
);

class CampoPasswordSeguro extends StatefulWidget {
  const CampoPasswordSeguro({super.key});

  @override
  State<CampoPasswordSeguro> createState() => _CampoPasswordSeguroState();
}

class _CampoPasswordSeguroState extends State<CampoPasswordSeguro> {
  // Estado puramente efímero: solo le importa a este campo de texto
  bool _ocultarClave = true;

  @override
  Widget build(BuildContext context) {
    return TextFormField(
      obscureText: _ocultarClave,
      decoration: InputDecoration(
        labelText: 'Contraseña de Acceso',
        prefixIcon: const Icon(Icons.lock_outline),
        suffixIcon: IconButton(
          icon: Icon(_ocultarClave ? Icons.visibility_off : Icons.visibility),
          onPressed: () {
            // Modificamos el valor e indicamos que se requiere un nuevo frame
            setState(() {
              _ocultarClave = !_ocultarClave;
            });
          },
        ),
      ),
    );
  }
}

// ANTIPATRÓN: Toda la pantalla se reconstruye cada vez que cambia el contador
class PantallaIneficienteState extends State<PantallaIneficiente> {
  int _contadorClicks = 0;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Clínica Central')),
      body: Column(
        children: [
          // Banner costoso con imágenes y gradientes (se reconstruye sin necesidad)
          const BannerPublicitarioPesado(),
          
          // Gráficos y tablas estadísticas (se recalculan innecesariamente)
          const GraficoEstadisticasMensuales(),

          // El único elemento que realmente cambia de valor:
          Text('Clicks registrados: $_contadorClicks'),
          ElevatedButton(
            onPressed: () => setState(() => _contadorClicks++),
            child: const Text('Sumar'),
          ),
        ],
      ),
    );
  }
}

// PATRÓN ÓPTIMO: Extraer el componente interactivo en su propia clase pequeña
class BotonContadorAislado extends StatefulWidget {
  const BotonContadorAislado({super.key});

  @override
  State<BotonContadorAislado> createState() => _BotonContadorAisladoState();
}

class _BotonContadorAisladoState extends State<BotonContadorAislado> {
  int _contador = 0;

  @override
  Widget build(BuildContext context) {
    // Al invocar setState aquí, solo se reconstruye este pequeño sub-árbol
    return Row(
      mainAxisSize: MainAxisSize.min,
      children: [
        Text('Clicks: $_contador', style: const TextStyle(fontWeight: FontWeight.bold)),
        const SizedBox(width: 12),
        FilledButton.tonal(
          onPressed: () => setState(() => _contador++),
          child: const Text('Incrementar'),
        ),
      ],
    );
  }
}

// Pantalla principal limpia: el método build es un StatelessWidget liviano
class PantallaEficiente extends StatelessWidget {
  const PantallaEficiente({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Portal Eficiente')),
      body: const Column(
        children: [
          BannerPublicitarioPesado(), // Widget constante: NUNCA se reconstruye
          GraficoEstadisticasMensuales(),
          Center(child: BotonContadorAislado()), // Único widget reactivo
        ],
      ),
    );
  }
}

# Instalación de provider en pubspec.yaml
flutter pub add provider

import 'package:flutter/material.dart';

// Modelo de datos para las consultas del paciente
class ConsultaMedica {
  final int id;
  final String doctor;
  final double costo;
  const ConsultaMedica({required this.id, required this.doctor, required this.costo});
}

// Gestor de estado que notifica a la interfaz gráfica
class CarritoClinica with ChangeNotifier {
  final List<ConsultaMedica> _items = [];

  // Exponemos una lista inmutable para proteger el estado interno
  List<ConsultaMedica> get items => List.unmodifiable(_items);

  double get total => _items.fold(0.0, (acum, elem) => acum + elem.costo);

  void agregarConsulta(ConsultaMedica consulta) {
    _items.add(consulta);
    // 1. Notifica de forma inmediata a los widgets que están escuchando
    notifyListeners();
  }

  void vaciar() {
    _items.clear();
    notifyListeners();
  }
}

import 'package:provider/provider.dart';

void main() {
  runApp(
    MultiProvider(
      providers: [
        // Instancia perezosa (lazy) creada automáticamente la primera vez que se lee
        ChangeNotifierProvider(create: (BuildContext context) => CarritoClinica()),
      ],
      child: const AppClinica(),
    ),
  );
}

class PantallaCajaClinica extends StatelessWidget {
  const PantallaCajaClinica({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Facturación de Consultas')),
      body: Column(
        children: [
          // 1. Consumer reconstruye ÚNICAMENTE este contenedor cuando cambia el carrito
          Consumer<CarritoClinica>(
            builder: (context, carrito, child) {
              return Card(
                margin: const EdgeInsets.all(16),
                child: Padding(
                  padding: const EdgeInsets.all(16),
                  child: Row(
                    mainAxisAlignment: MainAxisAlignment.spaceBetween,
                    children: [
                      // Usamos el child estático para el icono y texto fijo
                      child!,
                      Text(
                        'S/ ${carrito.total.toStringAsFixed(2)}',
                        style: const TextStyle(fontSize: 22, fontWeight: FontWeight.bold, color: Colors.teal),
                      ),
                    ],
                  ),
                ),
              );
            },
            // Este icono y texto se instancian una sola vez y se reutilizan
            child: const Row(
              children: [
                Icon(Icons.point_of_sale, size: 28),
                SizedBox(width: 8),
                Text('Total por Pagar:', style: TextStyle(fontSize: 16)),
              ],
            ),
          ),

          // 2. Botón que añade una consulta usando context.read (sin suscribirse a rebuilds)
          FilledButton.icon(
            icon: const Icon(Icons.add),
            label: const Text('Añadir Consulta Cardiológica (S/ 120.00)'),
            onPressed: () {
              context.read<CarritoClinica>().agregarConsulta(
                const ConsultaMedica(id: 1, doctor: 'Dr. Morales', costo: 120.00),
              );
            },
          ),
        ],
      ),
    );
  }
}

class VistaMedicosAsincrona extends StatefulWidget {
  const VistaMedicosAsincrona({super.key});

  @override
  State<VistaMedicosAsincrona> createState() => _VistaMedicosAsincronaState();
}

class _VistaMedicosAsincronaState extends State<VistaMedicosAsincrona> {
  // 1. REGLA DE ORO: La variable del Future se inicializa una sola vez en initState
  late final Future<List<String>> _medicosFuture;

  @override
  void initState() {
    super.initState();
    _medicosFuture = _cargarDoctoresDesdeServidor();
  }

  Future<List<String>> _cargarDoctoresDesdeServidor() async {
    // Simulamos un retardo de red de 2 segundos
    await Future.delayed(const Duration(seconds: 2));
    return ['Dr. Roberto Morales (Cardiología)', 'Dra. Elena Ramos (Pediatría)', 'Dr. Carlos Vega (Neurología)'];
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Equipo Médico')),
      body: FutureBuilder<List<String>>(
        future: _medicosFuture,
        builder: (BuildContext context, AsyncSnapshot<List<String>> snapshot) {
          // Fase 1: En espera de respuesta (cargando)
          if (snapshot.connectionState == ConnectionState.waiting) {
            return const Center(child: CircularProgressIndicator());
          }

          // Fase 2: Ocurrió un error en la comunicación
          if (snapshot.hasError) {
            return Center(
              child: Column(
                mainAxisAlignment: MainAxisAlignment.center,
                children: [
                  const Icon(Icons.cloud_off, size: 48, color: Colors.redAccent),
                  const SizedBox(height: 8),
                  Text('Error al conectar: ${snapshot.error}'),
                ],
              ),
            );
          }

          // Fase 3: Datos obtenidos con éxito
          if (snapshot.hasData) {
            final medicos = snapshot.data!;
            return ListView.builder(
              itemCount: medicos.length,
              itemBuilder: (context, i) => ListTile(
                leading: const Icon(Icons.medical_services),
                title: Text(medicos[i]),
              ),
            );
          }

          return const Center(child: Text('No hay datos disponibles'));
        },
      ),
    );
  }
}

// Flujo reactivo simulando el pulso cardíaco de un paciente en UCI
Stream<int> monitorCardiacoStream() async* {
  int ritmo = 72;
  while (true) {
    await Future.delayed(const Duration(seconds: 1));
    yield ritmo++; // Emite un nuevo valor por segundo
  }
}

class VistaMonitorUCI extends StatelessWidget {
  const VistaMonitorUCI({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Monitoreo en Tiempo Real')),
      body: Center(
        child: StreamBuilder<int>(
          stream: monitorCardiacoStream(),
          builder: (context, snapshot) {
            if (!snapshot.hasData) {
              return const Text('Calibrando sensores médicos...');
            }
            return Column(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                const Icon(Icons.favorite, color: Colors.redAccent, size: 64),
                const SizedBox(height: 12),
                Text(
                  '${snapshot.data} BPM',
                  style: const TextStyle(fontSize: 42, fontWeight: FontWeight.bold),
                ),
              ],
            );
          },
        ),
      ),
    );
  }
}

# Instalación de Riverpod oficial
flutter pub add flutter_riverpod

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

// 1. Declaración global inmutable del proveedor (sin depender de BuildContext)
final nombreClinicaProvider = Provider<String>((ref) => 'Clínica San Juan Internacional');

// 2. Envolver la aplicación en ProviderScope en la raíz
void main() {
  runApp(
    const ProviderScope(
      child: AppConRiverpod(),
    ),
  );
}

class AppConRiverpod extends StatelessWidget {
  const AppConRiverpod({super.key});

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      home: PantallaRiverpodEjemplo(),
    );
  }
}

// 3. Heredamos de ConsumerWidget en lugar de StatelessWidget
class PantallaRiverpodEjemplo extends ConsumerWidget {
  const PantallaRiverpodEjemplo({super.key});

  // Recibe WidgetRef ref como parámetro adicional en el build
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // Escuchamos el proveedor con ref.watch de forma segura
    final nombreClinica = ref.watch(nombreClinicaProvider);

    return Scaffold(
      appBar: AppBar(title: const Text('Arquitectura Moderna')),
      body: Center(
        child: Text(
          nombreClinica,
          style: const TextStyle(fontSize: 20, fontWeight: FontWeight.w600),
        ),
      ),
    );
  }
}

# Instalación de la biblioteca HTTP oficial
flutter pub add http

import 'dart:convert';

class MedicoModelo {
  final int id;
  final String nombre;
  final String especialidad;
  final String colegiatura;
  final bool activo;

  const MedicoModelo({
    required this.id,
    required this.nombre,
    required this.especialidad,
    required this.colegiatura,
    required this.activo,
  });

  // Constructor de fábrica para instanciar a partir de un Map JSON deserializado
  factory MedicoModelo.fromJson(Map<String, dynamic> json) {
    return MedicoModelo(
      id: json['id'] as int? ?? 0,
      nombre: json['nombre'] as String? ?? 'Sin nombre',
      especialidad: json['especialidad'] as String? ?? 'General',
      colegiatura: json['colegiatura'] as String? ?? 'CMP-00000',
      activo: json['activo'] as bool? ?? true,
    );
  }

  // Método para serializar a JSON al emitir peticiones POST o PUT
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'nombre': nombre,
      'especialidad': especialidad,
      'colegiatura': colegiatura,
      'activo': activo,
    };
  }
}

import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;

class MedicosApiService {
  static const String _baseUrl = 'https://api.clinicasanjuan.pe/v1';

  Future<List<MedicoModelo>> obtenerMedicos() async {
    final Uri url = Uri.parse('$_baseUrl/medicos');

    try {
      final response = await http.get(
        url,
        headers: {
          'Accept': 'application/json',
          'Authorization': 'Bearer TOKEN_JWT_CLINICA',
        },
      ).timeout(const Duration(seconds: 10)); // Timeout preventivo

      if (response.statusCode == 200) {
        // Deserializamos el string en una lista de mapas
        final List<dynamic> dataJson = jsonDecode(response.body);
        return dataJson.map((item) => MedicoModelo.fromJson(item)).toList();
      } else if (response.statusCode == 401) {
        throw Exception('Sesión expirada. Por favor inicie sesión nuevamente.');
      } else {
        throw Exception('Error en el servidor: Código ${response.statusCode}');
      }
    } on SocketException {
      // Sin acceso a internet o servidor inaccesible
      throw Exception('No hay conexión a internet. Verifique su red Wi-Fi o datos móviles.');
    } on TimeoutException {
      throw Exception('El servidor tardó demasiado en responder.');
    } catch (e) {
      throw Exception('Ocurrió un error inesperado: $e');
    }
  }

  // Petición POST para registrar una nueva cita
  Future<bool> agendarTurno({required int pacienteId, required int medicoId, required String fecha}) async {
    final Uri url = Uri.parse('$_baseUrl/citas');

    final response = await http.post(
      url,
      headers: {'Content-Type': 'application/json'},
      body: jsonEncode({
        'paciente_id': pacienteId,
        'medico_id': medicoId,
        'fecha_hora': fecha,
      }),
    );

    return response.statusCode == 201; // 201 Created
  }
}

# Instalación del plugin de persistencia local
flutter pub add shared_preferences

import 'package:shared_preferences/shared_preferences.dart';

Future<void> guardarAjustesUsuario(bool modoOscuro, String sedeClinica) async {
  // 1. Obtenemos la instancia del motor de almacenamiento
  final SharedPreferences prefs = await SharedPreferences.getInstance();

  // 2. Guardamos tipos primitivos
  await prefs.setBool('modo_oscuro_activo', modoOscuro);
  await prefs.setString('sede_preferida', sedeClinica);
  await prefs.setInt('ultimo_acceso_timestamp', DateTime.now().millisecondsSinceEpoch);
}

Future<Map<String, dynamic>> leerAjustesUsuario() async {
  final SharedPreferences prefs = await SharedPreferences.getInstance();

  // Lectura síncrona desde el caché en memoria de prefs
  final bool modoOscuro = prefs.getBool('modo_oscuro_activo') ?? false; // Valor por defecto
  final String sede = prefs.getString('sede_preferida') ?? 'Sede Central San Isidro';

  return {
    'modoOscuro': modoOscuro,
    'sede': sede,
  };
}

import 'dart:convert';
import 'package:shared_preferences/shared_preferences.dart';

class PreferenciasClinicaService {
  static const String _keyUsuario = 'paciente_sesion';

  // Guardar un objeto estructurado serializándolo a String JSON
  static Future<void> guardarSesionPaciente(Map<String, dynamic> paciente) async {
    final prefs = await SharedPreferences.getInstance();
    final String jsonString = jsonEncode(paciente);
    await prefs.setString(_keyUsuario, jsonString);
  }

  // Recuperar el objeto reconstruyéndolo desde JSON
  static Future<Map<String, dynamic>?> obtenerSesionPaciente() async {
    final prefs = await SharedPreferences.getInstance();
    final String? jsonString = prefs.getString(_keyUsuario);
    if (jsonString == null) return null;
    return jsonDecode(jsonString) as Map<String, dynamic>;
  }

  // Eliminar datos al cerrar sesión
  static Future<void> borrarSesion() async {
    final prefs = await SharedPreferences.getInstance();
    await prefs.remove(_keyUsuario);
  }
}

import 'package:flutter/material.dart';
import 'package:provider/provider.dart';

// 1. Modelo inmutable de la cita médica
class Cita {
  final String id;
  final String paciente;
  final String medico;
  final String especialidad;
  final String hora;
  final double costo;

  const Cita({
    required this.id,
    required this.paciente,
    required this.medico,
    required this.especialidad,
    required this.hora,
    required this.costo,
  });
}

// 2. Gestor de estado que administra las citas y el filtro activo
class GestorCitas extends ChangeNotifier {
  final List<Cita> _citas = [
    const Cita(id: '1', paciente: 'Juan Pérez', medico: 'Dr. Roberto Morales', especialidad: 'Cardiología', hora: '09:00 AM', costo: 150.0),
    const Cita(id: '2', paciente: 'María Gómez', medico: 'Dra. Elena Ramos', especialidad: 'Pediatría', hora: '10:30 AM', costo: 120.0),
    const Cita(id: '3', paciente: 'Carlos Silva', medico: 'Dr. Roberto Morales', especialidad: 'Cardiología', hora: '11:45 AM', costo: 150.0),
    const Cita(id: '4', paciente: 'Rosa Mendoza', medico: 'Dr. Carlos Vega', especialidad: 'Neurología', hora: '02:15 PM', costo: 180.0),
  ];

  String _especialidadFiltro = 'Todas';

  String get especialidadFiltro => _especialidadFiltro;

  List<Cita> get citasFiltradas {
    if (_especialidadFiltro == 'Todas') return List.unmodifiable(_citas);
    return _citas.where((c) => c.especialidad == _especialidadFiltro).toList();
  }

  void cambiarFiltro(String nuevaEspecialidad) {
    _especialidadFiltro = nuevaEspecialidad;
    notifyListeners();
  }

  void agregarCita(Cita nuevaCita) {
    _citas.insert(0, nuevaCita);
    notifyListeners();
  }

  void cancelarCita(String id) {
    _citas.removeWhere((c) => c.id == id);
    notifyListeners();
  }
}

void main() {
  runApp(
    ChangeNotifierProvider(
      create: (_) => GestorCitas(),
      child: const AppClinicaSanJuan(),
    ),
  );
}

class AppClinicaSanJuan extends StatelessWidget {
  const AppClinicaSanJuan({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      title: 'Clínica San Juan',
      theme: ThemeData(useMaterial3: true, colorSchemeSeed: Colors.teal),
      home: const PantallaPrincipalClinica(),
    );
  }
}

class PantallaPrincipalClinica extends StatelessWidget {
  const PantallaPrincipalClinica({super.key});

  @override
  Widget build(BuildContext context) {
    // Escuchamos el gestor de citas reactivamente
    final gestor = context.watch<GestorCitas>();
    final especialidades = ['Todas', 'Cardiología', 'Pediatría', 'Neurología'];

    return Scaffold(
      appBar: AppBar(
        scrolledUnderElevation: 3.0,
        title: const Text('Agenda Médica del Día', style: TextStyle(fontWeight: FontWeight.bold)),
        actions: [
          IconButton(
            icon: const Icon(Icons.info_outline),
            onPressed: () {
              ScaffoldMessenger.of(context).showSnackBar(
                SnackBar(
                  content: Text('Total de citas visibles: ${gestor.citasFiltradas.length}'),
                  behavior: SnackBarBehavior.floating,
                ),
              );
            },
          ),
        ],
      ),
      body: Column(
        children: [
          // 1. Selector de filtros con FilterChip horizontal
          SingleChildScrollView(
            scrollDirection: Axis.horizontal,
            padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
            child: Row(
              children: especialidades.map((esp) {
                final bool seleccionada = gestor.especialidadFiltro == esp;
                return Padding(
                  padding: const EdgeInsets.only(right: 8),
                  child: FilterChip(
                    selected: seleccionada,
                    label: Text(esp),
                    onSelected: (_) => gestor.cambiarFiltro(esp),
                  ),
                );
              }).toList(),
            ),
          ),

          // 2. Lista optimizada con ListView.builder
          Expanded(
            child: gestor.citasFiltradas.isEmpty
                ? const Center(child: Text('No hay citas registradas para este filtro.'))
                : ListView.builder(
                    itemCount: gestor.citasFiltradas.length,
                    itemBuilder: (context, index) {
                      final cita = gestor.citasFiltradas[index];
                      return Card(
                        margin: const EdgeInsets.symmetric(horizontal: 16, vertical: 6),
                        elevation: 1,
                        child: ListTile(
                          leading: CircleAvatar(
                            backgroundColor: Theme.of(context).colorScheme.primaryContainer,
                            child: const Icon(Icons.person, color: Colors.teal),
                          ),
                          title: Text(cita.paciente, style: const TextStyle(fontWeight: FontWeight.w600)),
                          subtitle: Text('${cita.especialidad} · ${cita.medico}\nHora: ${cita.hora}'),
                          trailing: IconButton(
                            icon: const Icon(Icons.cancel_outlined, color: Colors.redAccent),
                            tooltip: 'Cancelar Cita',
                            onPressed: () async {
                              // Confirmación modal antes de cancelar
                              final bool? confirmar = await showDialog<bool>(
                                context: context,
                                builder: (ctx) => AlertDialog(
                                  title: const Text('¿Cancelar turno?'),
                                  content: Text('¿Desea liberar el turno de las ${cita.hora} de ${cita.paciente}?'),
                                  actions: [
                                    TextButton(onPressed: () => Navigator.pop(ctx, false), child: const Text('No')),
                                    FilledButton(onPressed: () => Navigator.pop(ctx, true), child: const Text('Sí, liberar')),
                                  ],
                                ),
                              );

                              if (confirmar == true && context.mounted) {
                                gestor.cancelarCita(cita.id);
                                ScaffoldMessenger.of(context).showSnackBar(
                                  const SnackBar(content: Text('Cita liberada exitosamente.')),
                                );
                              }
                            },
                          ),
                        ),
                      );
                    },
                  ),
          ),
        ],
      ),
      floatingActionButton: FloatingActionButton.extended(
        icon: const Icon(Icons.add),
        label: const Text('Nuevo Turno'),
        onPressed: () => _mostrarModalNuevaCita(context),
      ),
    );
  }

  void _mostrarModalNuevaCita(BuildContext context) {
    final pacienteCtrl = TextEditingController();
    showDialog(
      context: context,
      builder: (ctx) => AlertDialog(
        title: const Text('Registrar Nuevo Turno'),
        content: TextField(
          controller: pacienteCtrl,
          decoration: const InputDecoration(labelText: 'Nombre completo del paciente'),
        ),
        actions: [
          TextButton(onPressed: () => Navigator.pop(ctx), child: const Text('Cancelar')),
          FilledButton(
            onPressed: () {
              if (pacienteCtrl.text.trim().isNotEmpty) {
                context.read<GestorCitas>().agregarCita(
                  Cita(
                    id: DateTime.now().millisecondsSinceEpoch.toString(),
                    paciente: pacienteCtrl.text.trim(),
                    medico: 'Dr. Roberto Morales',
                    especialidad: 'Cardiología',
                    hora: '04:00 PM',
                    costo: 150.0,
                  ),
                );
                Navigator.pop(ctx);
              }
            },
            child: const Text('Guardar'),
          ),
        ],
      ),
    );
  }
}

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';

// 1. Prueba Unitaria: Valida la lógica pura sin renderizar UI
void main() {
  group('Pruebas del Modelo Cita', () {
    test('El cálculo de costo debe ser exacto', () {
      const costoConsulta = 150.0;
      expect(costoConsulta > 0, true);
    });
  });

  // 2. Prueba de Widgets: Simula interacción en un entorno virtual sin emulador
  testWidgets('El botón de nuevo turno debe mostrar el diálogo modal', (WidgetTester tester) async {
    // Montamos un widget envuelto en MaterialApp para simular el entorno real
    await tester.pumpWidget(
      MaterialApp(
        home: Scaffold(
          body: Center(
            child: FilledButton(
              onPressed: () {},
              child: const Text('Nuevo Turno'),
            ),
          ),
        ),
      ),
    );

    // Verificamos que el texto esté presente en la pantalla
    expect(find.text('Nuevo Turno'), findsOneWidget);

    // Simulamos un toque táctil en el botón
    await tester.tap(find.byType(FilledButton));

    // pumpAndSettle espera a que todas las micro-animaciones finalicen
    await tester.pumpAndSettle();
  });
}

# 1. Android: Generar Android App Bundle (AAB) para Google Play con ofuscación
flutter build appbundle --release --obfuscate --split-debug-info=build/app/outputs/symbols

# 2. Android: Generar APKs individuales divididos por arquitectura (reduce el peso un 60%)
flutter build apk --split-per-abi --release

# 3. iOS: Generar el paquete de distribución para TestFlight y App Store
flutter build ipa --release

# 4. Web: Compilar aplicación web optimizada para producción
flutter build web --release