using System;

namespace LibS7Adv
{
    /// <summary>
    /// Ejemplos de uso del nuevo sistema de normalización de direcciones PLC
    /// Demuestra cómo diferentes notaciones se convierten automáticamente al formato Sharp7
    /// </summary>
    public class ExampleAddressNormalization
    {
        private PLCViewModel plc;

        public ExampleAddressNormalization()
        {
            plc = new PLCViewModel();
        }

        /// <summary>
        /// Demuestra la normalización automática de direcciones con diferentes notaciones
        /// </summary>
        public void ExampleAddressNormalizationUsage()
        {
            Console.WriteLine("=== Ejemplo de Normalización de Direcciones PLC ===");
            Console.WriteLine("Todas estas direcciones se normalizan automáticamente para Sharp7:");
            Console.WriteLine();

            // Configurar para Sharp7
            plc.PlcData.ConnectionType = ConnectionType.Sharp7;
            plc.PlcData.IP = "192.168.1.100";
            
            // Nota: No necesitamos conectar para demostrar la normalización
            // plc.Connect();

            Console.WriteLine("=== NOTACIONES DE INPUTS (Entradas) ===");
            
            // Todas estas formas son equivalentes y se normalizan a IW0, IW2, etc.
            Console.WriteLine("Notación Alemana con P:");
            Console.WriteLine("  PEW0  → Normalizado a: IW0");
            Console.WriteLine("  PEW2  → Normalizado a: IW2");
            Console.WriteLine("  PEB0  → Normalizado a: IB0");
            Console.WriteLine("  PED0  → Normalizado a: ID0");
            
            Console.WriteLine();
            Console.WriteLine("Notación Alemana sin P:");
            Console.WriteLine("  EW0   → Normalizado a: IW0");
            Console.WriteLine("  EW2   → Normalizado a: IW2");
            Console.WriteLine("  EB0   → Normalizado a: IB0");
            Console.WriteLine("  ED0   → Normalizado a: ID0");
            
            Console.WriteLine();
            Console.WriteLine("Notación Americana con P:");
            Console.WriteLine("  PIW0  → Normalizado a: IW0");
            Console.WriteLine("  PIW2  → Normalizado a: IW2");
            Console.WriteLine("  PIB0  → Normalizado a: IB0");
            Console.WriteLine("  PID0  → Normalizado a: ID0");
            
            Console.WriteLine();
            Console.WriteLine("Notación Americana (ya compatible):");
            Console.WriteLine("  IW0   → Sin cambios: IW0");
            Console.WriteLine("  IW2   → Sin cambios: IW2");
            Console.WriteLine("  IB0   → Sin cambios: IB0");
            Console.WriteLine("  ID0   → Sin cambios: ID0");

            Console.WriteLine();
            Console.WriteLine("=== NOTACIONES DE OUTPUTS (Salidas) ===");
            
            Console.WriteLine("Notación Alemana con P:");
            Console.WriteLine("  PAW0  → Normalizado a: QW0");
            Console.WriteLine("  PAW2  → Normalizado a: QW2");
            Console.WriteLine("  PAB0  → Normalizado a: QB0");
            Console.WriteLine("  PAD0  → Normalizado a: QD0");
            
            Console.WriteLine();
            Console.WriteLine("Notación Alemana sin P:");
            Console.WriteLine("  AW0   → Normalizado a: QW0");
            Console.WriteLine("  AW2   → Normalizado a: QW2");
            Console.WriteLine("  AB0   → Normalizado a: QB0");
            Console.WriteLine("  AD0   → Normalizado a: QD0");
            
            Console.WriteLine();
            Console.WriteLine("Notación Americana con P:");
            Console.WriteLine("  POW0  → Normalizado a: QW0");
            Console.WriteLine("  POW2  → Normalizado a: QW2");
            Console.WriteLine("  POB0  → Normalizado a: QB0");
            Console.WriteLine("  POD0  → Normalizado a: QD0");
            
            Console.WriteLine();
            Console.WriteLine("Notación Americana (ya compatible):");
            Console.WriteLine("  QW0   → Sin cambios: QW0");
            Console.WriteLine("  QW2   → Sin cambios: QW2");
            Console.WriteLine("  QB0   → Sin cambios: QB0");
            Console.WriteLine("  QD0   → Sin cambios: QD0");

            Console.WriteLine();
            Console.WriteLine("=== NOTACIONES DE BITS ===");
            
            Console.WriteLine("Entradas (Inputs):");
            Console.WriteLine("  PE0.0 → Normalizado a: I0.0");
            Console.WriteLine("  E0.0  → Normalizado a: I0.0");
            Console.WriteLine("  PI0.0 → Normalizado a: I0.0");
            Console.WriteLine("  I0.0  → Sin cambios: I0.0");
            
            Console.WriteLine();
            Console.WriteLine("Salidas (Outputs):");
            Console.WriteLine("  PA0.0 → Normalizado a: Q0.0");
            Console.WriteLine("  A0.0  → Normalizado a: Q0.0");
            Console.WriteLine("  PO0.0 → Normalizado a: Q0.0");
            Console.WriteLine("  Q0.0  → Sin cambios: Q0.0");

            Console.WriteLine();
            Console.WriteLine("=== DATA BLOCKS (sin cambios) ===");
            Console.WriteLine("  DB1.DBX0.0 → Sin cambios: DB1.DBX0.0");
            Console.WriteLine("  DB1.DBW0   → Sin cambios: DB1.DBW0");
            Console.WriteLine("  DB1.DBD0   → Sin cambios: DB1.DBD0");

            Console.WriteLine();
            Console.WriteLine("=== MARCAS/MEMORY (sin cambios) ===");
            Console.WriteLine("  M0.0  → Sin cambios: M0.0");
            Console.WriteLine("  MW0   → Sin cambios: MW0");
            Console.WriteLine("  MD0   → Sin cambios: MD0");
        }

        /// <summary>
        /// Ejemplo práctico mostrando cómo usar diferentes notaciones en el código
        /// </summary>
        public void ExamplePracticalUsage()
        {
            Console.WriteLine("=== Ejemplo Práctico de Uso ===");
            Console.WriteLine("Ahora puedes usar cualquier notación en tu código:");
            Console.WriteLine();

            // Configurar conexión
            plc.PlcData.ConnectionType = ConnectionType.Sharp7;
            plc.PlcData.IP = "192.168.1.100";
            plc.Connect();

            if (plc.IsConnected)
            {
                Console.WriteLine("=== Usando diferentes notaciones (todas equivalentes) ===");
                
                try
                {
                    // Todas estas formas de leer Input Word 0 son equivalentes:
                    Console.WriteLine("Leyendo Input Word 0 con diferentes notaciones:");
                    
                    string? value1 = plc.LeerNumber("IW0");    // Americano estándar
                    string? value2 = plc.LeerNumber("PIW0");   // Americano con P
                    string? value3 = plc.LeerNumber("EW0");    // Alemán
                    string? value4 = plc.LeerNumber("PEW0");   // Alemán con P
                    
                    Console.WriteLine($"  IW0  = {value1}");
                    Console.WriteLine($"  PIW0 = {value2} (normalizado a IW0)");
                    Console.WriteLine($"  EW0  = {value3} (normalizado a IW0)");
                    Console.WriteLine($"  PEW0 = {value4} (normalizado a IW0)");
                    
                    Console.WriteLine();
                    Console.WriteLine("Leyendo Input Bits con diferentes notaciones:");
                    
                    bool? bit1 = plc.LeerBool("I0.0");     // Americano estándar
                    bool? bit2 = plc.LeerBool("PI0.0");    // Americano con P
                    bool? bit3 = plc.LeerBool("E0.0");     // Alemán
                    bool? bit4 = plc.LeerBool("PE0.0");    // Alemán con P
                    
                    Console.WriteLine($"  I0.0  = {bit1}");
                    Console.WriteLine($"  PI0.0 = {bit2} (normalizado a I0.0)");
                    Console.WriteLine($"  E0.0  = {bit3} (normalizado a I0.0)");
                    Console.WriteLine($"  PE0.0 = {bit4} (normalizado a I0.0)");
                    
                    Console.WriteLine();
                    Console.WriteLine("Escribiendo Output con diferentes notaciones:");
                    
                    // Todas estas formas de escribir Output Word 0 son equivalentes:
                    plc.EscribirNumber("QW0", 1000);   // Americano estándar
                    plc.EscribirNumber("POW0", 1001);  // Americano con P (normalizado a QW0)
                    plc.EscribirNumber("AW0", 1002);   // Alemán (normalizado a QW0)
                    plc.EscribirNumber("PAW0", 1003);  // Alemán con P (normalizado a QW0)
                    
                    Console.WriteLine("  ✓ Escrito en QW0 usando notación americana");
                    Console.WriteLine("  ✓ Escrito en POW0 (normalizado a QW0)");
                    Console.WriteLine("  ✓ Escrito en AW0 (normalizado a QW0)");
                    Console.WriteLine("  ✓ Escrito en PAW0 (normalizado a QW0)");
                    
                    Console.WriteLine();
                    Console.WriteLine("=== Usando funciones Tag con normalización ===");
                    
                    // Las funciones Tag también usan la normalización automática
                    int? inputValue = plc.LeerTagInt16("PEW2");    // Alemán con P → IW2
                    plc.EscribirTagInt16("PAW2", 2500);           // Alemán con P → QW2
                    
                    bool inputBit = plc.LeerTagBool("E0.1");      // Alemán → I0.1
                    plc.EscribirTagBool("A0.1", true);           // Alemán → Q0.1
                    
                    Console.WriteLine($"  PEW2 (→IW2) = {inputValue}");
                    Console.WriteLine($"  E0.1 (→I0.1) = {inputBit}");
                    Console.WriteLine("  ✓ PAW2 (→QW2) = 2500");
                    Console.WriteLine("  ✓ A0.1 (→Q0.1) = true");
                    
                    Console.WriteLine();
                    Console.WriteLine("¡La normalización es completamente transparente!");
                    Console.WriteLine("Puedes usar la notación que prefieras o con la que estés familiarizado.");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error: {ex.Message}");
                }
            }
            else
            {
                Console.WriteLine($"Error de conexión: {plc.PlcData.LastError}");
            }

            plc.Disconnect();
        }

        /// <summary>
        /// Muestra todas las conversiones soportadas
        /// </summary>
        public void ShowSupportedConversions()
        {
            Console.WriteLine("=== Tabla Completa de Conversiones Soportadas ===");
            Console.WriteLine();
            
            Console.WriteLine("INPUTS (Entradas):");
            Console.WriteLine("  Alemán con P:  PEW0, PEB0, PED0, PE0.0");
            Console.WriteLine("  Alemán sin P:  EW0,  EB0,  ED0,  E0.0");
            Console.WriteLine("  Americano+P:   PIW0, PIB0, PID0, PI0.0");
            Console.WriteLine("  Americano:     IW0,  IB0,  ID0,  I0.0  ← Formato destino");
            Console.WriteLine();
            
            Console.WriteLine("OUTPUTS (Salidas):");
            Console.WriteLine("  Alemán con P:  PAW0, PAB0, PAD0, PA0.0");
            Console.WriteLine("  Alemán sin P:  AW0,  AB0,  AD0,  A0.0");
            Console.WriteLine("  Americano+P:   POW0, POB0, POD0, PO0.0");
            Console.WriteLine("  Americano:     QW0,  QB0,  QD0,  Q0.0  ← Formato destino");
            Console.WriteLine();
            
            Console.WriteLine("SIN CAMBIOS:");
            Console.WriteLine("  Data Blocks:   DB1.DBX0.0, DB1.DBW0, DB1.DBD0");
            Console.WriteLine("  Marcas:        M0.0, MW0, MD0");
            Console.WriteLine("  Ya americano:  IW0, QW0, I0.0, Q0.0");
            Console.WriteLine();
            
            Console.WriteLine("TIPOS DE DATOS:");
            Console.WriteLine("  W = Word (16 bits)");
            Console.WriteLine("  B = Byte (8 bits)"); 
            Console.WriteLine("  D = DWord (32 bits)");
            Console.WriteLine("  X = Bit (para DB), sin sufijo para I/Q bits");
        }
    }
}