using Microsoft.Extensions.Configuration;
using MP.MONO.Core;
using MP.MONO.Core.CONF;
using MP.MONO.Core.DTO;
using MP.MONO.Data;
using MP.MONO.Data.Controllers;
using MP.MONO.Data.DbModels;
using MP.MONO.DECODER;
using Newtonsoft.Json;
using NLog;
using NLua;
using StackExchange.Redis;

// See https://aka.ms/new-console-template for more information

// init parte config, vedere https://blog.hildenco.com/2020/05/configuration-in-net-core-console.html
var env = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
var builder = new ConfigurationBuilder()
    .AddJsonFile($"appsettings.json", true, true)
    .AddJsonFile($"appsettings.{env}.json", true, true)
    .AddEnvironmentVariables();
var config = builder.Build();

// init LOG
Logger Log = LogManager.GetCurrentClassLogger();

// initi va di base
string lineSep = "---------------------------------------------";
Console.WriteLine(lineSep);
Console.WriteLine("Start DECODER with LUA integration!");
Console.WriteLine("");
Console.WriteLine("Running - press CTRL-C to stop");
Console.WriteLine(lineSep);
Console.WriteLine("");

// init DB
// init info x DB
string dbServerAddr = config["DbConfig:Server"];
string nKey = config["DbConfig:nKey"];
string sKey = config["DbConfig:sKey"];
DbConfig.InitDb(dbServerAddr, nKey, sKey);
// inizializzo il DB e creo (se necessario) l'utente
DbConfig.CheckUser(nKey, sKey);
// verifico se serve applicazione migrazioni
DbConfig.ExecMigrationMain();
//DbConfig.ExecMigrationIdentity();

// altri parametri per check vari
string connStringDB = DbConfig.CONNECTION_STRING;
MpDbController dbController = null!;
if (string.IsNullOrEmpty(connStringDB))
{
    Log.Error("ConnString empty!");
}
else
{
    dbController = new MpDbController();
    Log.Info("DbController OK");
    Console.WriteLine("DbController OK");
}

// init info di base
int MachineId = 1;
int.TryParse(config.GetValue<string>("MachineId"), out MachineId);

// init oggetti REDIS + messagePipe...
ConnectionMultiplexer.SetFeatureFlag("preventthreadtheft", true);
ConnectionMultiplexer redisConn = ConnectionMultiplexer.Connect(config.GetConnectionString("Redis"));
IDatabase? redisDb = redisConn.GetDatabase();

// preparo oggetti da configurare
List<BaseAlarmConf>? alarmsConf = new List<BaseAlarmConf>();
List<MachineMode>? machineModeConf = new List<MachineMode>();
List<MachineStatus>? machineStatusConf = new List<MachineStatus>();
// gestione configurazioni da redis
setupConf();

/* --------------------------------
 * Setup Gestione ALLARMI
 * --------------------------------*/
// init classe gestione allarmi con LUA
AlarmsManager alarmsMan = new AlarmsManager();
// inizializzo gestione messagePipe da Redis x allarmi
MessagePipe alarmsPipe = new MessagePipe(redisConn, Constants.ALARM_M_QUEUE);
MessagePipe alarmsValPipe = new MessagePipe(redisConn, Constants.ALARM_ACT_QUEUE);
// registro gestione eventi
alarmsValPipe.EA_NewMessage += AlarmsValPipe_EA_NewMessage;

/* --------------------------------
 * Setup Gestione Parametri
 * --------------------------------*/
ParamsManager paramMan = new ParamsManager();
// inizializzo gestione messagePipe da Redis x allarmi
MessagePipe paramsPipe = new MessagePipe(redisConn, Constants.PARAMS_M_QUEUE);
MessagePipe paramsValPipe = new MessagePipe(redisConn, Constants.PARAMS_ACT_QUEUE);
// registro gestione eventi
paramsValPipe.EA_NewMessage += ParamsValPipe_EA_NewMessage;


/* --------------------------------
 * Funzioni / metodi accessori
 * --------------------------------*/
/// <summary>
/// Recupero da redis le conf (es modi,stati,allarmi)
/// </summary>
void setupConf()
{
    // recupero valori e deserializzo
    string rawData = "";

    // machine conf
    rawData = redisDb.StringGet(Constants.STATUS_CONF_KEY);
    if (!string.IsNullOrEmpty(rawData))
    {
        machineStatusConf = JsonConvert.DeserializeObject<List<MachineStatus>>(rawData);
    }

    // machine mode
    rawData = redisDb.StringGet(Constants.MODE_CONF_KEY);
    if (!string.IsNullOrEmpty(rawData))
    {
        machineModeConf = JsonConvert.DeserializeObject<List<MachineMode>>(rawData);
    }

    // allarmi, versione base...
    rawData = redisDb.StringGet(Constants.ALARMS_CONF_KEY);
    if (!string.IsNullOrEmpty(rawData))
    {
        alarmsConf = JsonConvert.DeserializeObject<List<BaseAlarmConf>>(rawData);
    }
}
/// <summary>
/// Gestione evento ricezione messaggi allarmi
/// </summary>
void AlarmsValPipe_EA_NewMessage(object? sender, EventArgs e)
{
    PubSubEventArgs currArgs = (PubSubEventArgs)e;
    // conversione on-the-fly List<string> --> allarmi
    if (!string.IsNullOrEmpty(currArgs.newMessage))
    {
        try
        {
            // verifico codici allarmi ricevuti
            var alarmList = JsonConvert.DeserializeObject<Dictionary<string, uint>>(currArgs.newMessage);
            if (alarmList != null)
            {
                // variabili accessorie
                List<string> activeAlarmList = new List<string>();
                List<AlarmLogModel> alarmLogList = new List<AlarmLogModel>();

                // rileggo da REDIS la conf attuale allarmi da area ALARMS_SETT_KEY, altrimenti uso quella letta inizialmente da conf base
                List<BaseAlarmConf>? currAlarmsConf = new List<BaseAlarmConf>();
                string rawData = redisDb.StringGet(Constants.ALARMS_SETT_KEY);
                // se trovati uso questi...
                if (!string.IsNullOrEmpty(rawData))
                {
                    currAlarmsConf = JsonConvert.DeserializeObject<List<BaseAlarmConf>>(rawData);
                }
                // altrimenti uso quelli di default inizialmente letti
                else
                {
                    currAlarmsConf = alarmsConf;
                }
                if (currAlarmsConf != null)
                {
                    // ciclo x ogni bank di allarmi configurato
                    foreach (var alarmData in currAlarmsConf)
                    {
                        // recupero valore allarme
                        var bankVal = alarmList.FirstOrDefault(x => x.Key == alarmData.memAddr);
                        uint actVal = !string.IsNullOrEmpty(bankVal.Key) ? bankVal.Value : 0;
                        // valutare se dividere in 2 da 16... FIXME TODO
                        var bankAlarmList = AlarmsManager.processData(alarmData.memAddr, alarmData.messages, alarmData.silenceMask[0], alarmData.disableMask[0], alarmData.alarmsState[0], ref actVal);
                        // salvo nuovo valore in oggetto...
                        if (alarmData.alarmsState[0] != actVal)
                        {
                            alarmData.alarmsState[0] = actVal;
                            // aggiungo...
                            activeAlarmList.AddRange(bankAlarmList);

                            AlarmLogModel newAlarm = new AlarmLogModel()
                            {
                                MachineId = MachineId,
                                DtRif = DateTime.Now,
                                MemAddress = bankVal.Key,
                                Index = alarmData != null ? alarmData.index : 0,
                                Status = alarmData != null ? (uint)bankVal.Value & alarmData.silenceMask[0] & alarmData.disableMask[0] : (uint)bankVal.Value,
                                ValDecoded = bankAlarmList.Count > 0 ? string.Join(", ", bankAlarmList) : "All OK"
                            };
                            alarmLogList.Add(newAlarm);
                        }
                    }
                }

                // salvo status aggiornato allarme...
                redisDb.StringSet(Constants.ALARMS_SETT_KEY, JsonConvert.SerializeObject(currAlarmsConf));

                // serializzo l'elenco allarmi...
                string serAlarms = "[]";
                serAlarms = JsonConvert.SerializeObject(activeAlarmList);
                // invio sulla message pipeline corretta TUTTI gli allarmi serializzati
                alarmsPipe.saveAndSendMessage(Constants.ALARM_CURR_KEY, serAlarms);
                if (dbController != null)
                {
                    // salvo sul DB
                    _ = dbController.AlarmLogInsertMany(alarmLogList).Result;

#if false
                    // salvo nel DB lo stato dei bank di allarme
                    foreach (var dbItem in alarmLogList)
                    {
                        _ = dbController.AlarmLogInsert(dbItem).Result;
                    } 
#endif
                }
            }
        }
        catch (Exception exc)
        {
            Log.Error($"Eccezione in AlarmsValPipe_EA_NewMessage:{Environment.NewLine}{exc}");
        }
    }
}
/// <summary>
/// Gestione evento ricezione messaggi parametri
/// </summary>
void ParamsValPipe_EA_NewMessage(object? sender, EventArgs e)
{
    PubSubEventArgs currArgs = (PubSubEventArgs)e;
    // conversione on-the-fly Dictionary<string,int> --> parametri valorizzati (tra quelli configurati)
    if (!string.IsNullOrEmpty(currArgs.newMessage))
    {
        try
        {
            // verifico codici ricevuti
            var paramsList = JsonConvert.DeserializeObject<Dictionary<string, double>>(currArgs.newMessage);
            if (paramsList != null)
            {
                // recupero elenco parametri salvati in redis...
                List<DisplayDataDTO>? redisParamConf = new List<DisplayDataDTO>();
                List<DisplayDataDTO> updatedParams = new List<DisplayDataDTO>();
                string rawData = redisDb.StringGet(Constants.PARAMS_CONF_KEY);
                if (!string.IsNullOrEmpty(rawData))
                {
                    redisParamConf = JsonConvert.DeserializeObject<List<DisplayDataDTO>>(rawData);
                    // se ho i parametri...
                    if (redisParamConf != null)
                    {
                        // ciclo x ogni valore ricevuto da message service...
                        foreach (var item in paramsList)
                        {
                            // cerco il parametro corrispondente...
                            var currParam = redisParamConf.FirstOrDefault(x => x.Title == item.Key);
                            if (currParam != null)
                            {
                                currParam.ValueNum = item.Value;
                                currParam.Value = $"{item.Value.ToString(currParam.DisplFormat)}";
                                // aggiungo a lista...
                                updatedParams.Add(currParam);
                            }
                        }
                        if (dbController != null)
                        {
                            // verifico x ogni parametro se sia completato il periodo di campionamento...
                            var params2save = paramMan.processData(paramsList, redisParamConf);
                            if (params2save.Count > 0)
                            {
                                // salvo sul DB
                                _ = dbController.DataLogInsertMany(params2save).Result;
                            }
                        }
                    }
                }

                // invio sulla message pipeline corretta TUTTI i parametri aggiornati serializzati
                string updRawVal = JsonConvert.SerializeObject(redisParamConf);
                paramsPipe.saveAndSendMessage(Constants.PARAMS_CURR_KEY, updRawVal);
            }
        }
        catch (Exception exc)
        {
            Log.Error($"Eccezione in ParamsValPipe_EA_NewMessage:{Environment.NewLine}{exc}");
        }
    }
}


/* --------------------------------
 * MAIN
 * --------------------------------*/

// Ciclo infinito x attesa chiusura con CTRL-C
do
{
    Thread.Sleep(100);
} while (true);