using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Web.Http;
using Harrenhal.Merchant.Utility;
using StackExchange.Redis;
using StackExchange.Redis.Extensions.Core;
using StackExchange.Redis.Extensions.Newtonsoft;
using Sylvanas.Logging;
using Sylvanas.Logging.Extensions;

namespace Harrenhal.Merchant.Controllers
{
    [RoutePrefix("api/event")]
    public class EventController : ApiController
    {
        private static readonly ILogger Logger = LoggerCache.GetLogger(typeof(EventController));
        private static readonly string DispatchSuccessEventPrefix = "DispatchSuccess";
        private static Timer _timer = default(Timer);

        private static readonly ConcurrentDictionary<string, StreamWriter> StreamWriters =
            new ConcurrentDictionary<string, StreamWriter>();

        public EventController()
        {
            _timer = _timer ?? new Timer(TimerCallback, null, 0, 1000);
        }

        public HttpResponseMessage Get(string userid)
        {
            var response = Request.CreateResponse();
            response.Content =
                new PushStreamContent(
                    (stream, httpContent, transportContext) =>
                    {
                        var writer = new StreamWriter(stream);
                        StreamWriters.TryAdd(userid, writer);
                    }, "text/event-stream");

            return response;
        }

        private static void TimerCallback(object state)
        {
            _timer.Change(Timeout.Infinite, Timeout.Infinite);
            try
            {
                foreach (var streamWriter in StreamWriters)
                {
                    //ConnectionMultiplexer connectionMultiplexer =
                    //    RedisUtility.GetConnection(
                    //        ConfigurationManager.ConnectionStrings["My.Redis.Cache"].ConnectionString);

                    //var client = new StackExchangeRedisCacheClient(connectionMultiplexer,
                    //    new NewtonsoftSerializer());
                    //var key =
                    //    client.SearchKeys($"{GetLocalizedKey(DispatchSuccessEventPrefix, streamWriter.Key)}*")
                    //        .FirstOrDefault();

                    //var writer = streamWriter.Value;
                    //if (key != null)
                    //{
                    //    Logger.Error($"key:{key}");
                    //    var database = connectionMultiplexer.GetDatabase();
                    //    var message = database.StringGet(key);
                    //    Logger.Error($"message:{message}");

                    //    if (!message.IsNullOrEmpty)
                    //    {
                    //        database.KeyDelete(key);

                    //        writer.WriteLine("data:" + message + "\n");
                    //    }
                    //    else
                    //    {
                    //        writer.WriteLine("data:" + "\n");
                    //    }
                    //}
                    //else
                    //{
                    //    writer.WriteLine("data:" + "\n");
                    //}
                    //writer.Flush();
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex, "获取通知消息失败");
            }
            finally
            {
                _timer.Change(1000, 1000);
            }
        }

        private static string GetLocalizedKey(string prefix, string key)
        {
            return prefix + ":Cache:" + key;
            
        }
    }
}