using System;
using System.Threading;
using System.Threading.Tasks;

namespace Recetas.Multithreading.R0404
{
    public class ConversionAPMaTPL
    {
        public static void Main()
        {
            // Variables auxiliares...
            int idThread;
            TareaAsincronica ta = Prueba;
            TareaAsincronicaIncompatible tai = Prueba;
            
            Console.WriteLine ("\nOpción 1:\n");
            
            // Tarea para el delegado TareaAsincronica:
            Task<string> tarea = Task<string>.Factory.FromAsync(
                ta.BeginInvoke("ThreadTareaAsincronica", Callback, "Invocación asincrónica con delegado."),
                ta.EndInvoke
            );
            
            // Continuar tarea:
            tarea.ContinueWith(t => Console.WriteLine ("El callback ha terminado.\n\tEjecución de continuación.\n\t\tResultado: {0}", 
                t.Result));
            
            // Mientras termina la tarea muestra su estado:
            while (!tarea.IsCompleted)
            {
                Console.WriteLine ("Estado de la tarea: {0}", tarea.Status);
                Thread.Sleep (TimeSpan.FromSeconds(0.5));
            }
            
            // El último estado de la tarea:
            Console.WriteLine ("Último estado tarea: {0}", tarea.Status);
            Thread.Sleep(TimeSpan.FromSeconds(1));
            
            
            Console.WriteLine ("----------------------------------------");
            Console.WriteLine ();
            Console.WriteLine ("Opción 2:\n");
            
            // Variante de la opción 1:
            tarea = Task<string>.Factory.FromAsync(
                ta.BeginInvoke, ta.EndInvoke, "ThreadTareaAsincronica", "Invocación asincrónica con delegado."
            );
            
            // Continuación tarea:
            tarea.ContinueWith(t => Console.WriteLine ("Tarea completada.\n\tEjecución de continuación.\n\tResultado: {0}", 
                t.Result));
                
            // Mientras termina la tarea muestra su estado:
            while (!tarea.IsCompleted)
            {
                Console.WriteLine ("Estado de la tarea: {0}", tarea.Status);
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
            }
            
            // El último estado de la tarea:
            Console.WriteLine ("Último estado tarea: {0}", tarea.Status);
            Thread.Sleep(TimeSpan.FromSeconds(1));
            
            
            Console.WriteLine ("------------------------------------------");
            Console.WriteLine ();
            Console.WriteLine ("Opción 3:\n");
            
            // Envoltura del callback:
            IAsyncResult ar = tai.BeginInvoke(out idThread, Callback, "Invocación asincrónica de delegado.");
            
            tarea = Task<string>.Factory.FromAsync(ar, _ => tai.EndInvoke(out idThread, ar));
            
            // Continuación tarea:
            tarea.ContinueWith( t => 
                Console.WriteLine("Tarea completada.\n\tEjecución de continuación.\n\tResultado: {0}\n\tID Thread: {1}",
                    t.Result, idThread));
                    
            // Mientras termina la tarea muestra su estado:
            while (!tarea.IsCompleted)
            {
                Console.WriteLine ("Estado de la tarea: {0}", tarea.Status);
                Thread.Sleep(TimeSpan.FromSeconds(0.5));
            }
            
            Console.WriteLine ();
            Console.WriteLine ("Último estado tarea: {0}", tarea.Status);
            
            Thread.Sleep(TimeSpan.FromSeconds(1));
            
            Console.WriteLine ();
        }

        // Delegado con firma directamente compatible con TPL:
        private delegate string TareaAsincronica(string nombreThread);
        
        // Delegado con firma no compatible con TPL:
        private delegate string TareaAsincronicaIncompatible(out int idThread);
        
        // Callback para respuesta a llamadas asincrónicas:
        private static void Callback(IAsyncResult ar)
        {
            Console.WriteLine ("Iniciando callback...");
            Console.WriteLine ("Estado pasado al callback: {0}", ar.AsyncState);
            Console.WriteLine ("¿Thread del pool de threads?: {0}", 
                Thread.CurrentThread.IsThreadPoolThread);
            Console.WriteLine ("ID del thread: {0}", Thread.CurrentThread.ManagedThreadId);
        }
        
        // Método para ejecución asincrónica:
        private static string Prueba(string nombreThread)
        {
            Console.WriteLine ("Iniciando prueba...");
            Console.WriteLine ("¿Thread del pool de threads?: {0}", 
                Thread.CurrentThread.IsThreadPoolThread);
            
            // Espera simulada:
            Thread.Sleep(TimeSpan.FromSeconds(2));
            
            Thread.CurrentThread.Name = nombreThread;

            // Resultado:
            return String.Format("-Nombre thread: {0}-", Thread.CurrentThread.Name);
        }
        
        // Método para ejecución asincrónica:
        private static string Prueba(out int idThread)
        {
            Console.WriteLine ("Iniciando prueba...");
            Console.WriteLine ("¿Thread del pool de threads?: {0}", 
                Thread.CurrentThread.IsThreadPoolThread);
                
            // Simulación de espera:
            Thread.Sleep(TimeSpan.FromSeconds(2));
            
            idThread = Thread.CurrentThread.ManagedThreadId;
            
            // Resultado:
            return String.Format("-ID del thread del pool de threads: {0}-", idThread);
        }
    }
}