using AppLibs.Libs;
using Dapper;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Razor.Language.Intermediate;
using Microsoft.VisualBasic;
using MySqlConnector;
using Newtonsoft.Json;
using System.Data.Common;
using System.Xml.Linq;
using TWASys_App.Dapper.AExtentions;
using TWASys_App.DBModels;

namespace TWASys_App.Models
{
    public class StorageModel : ModelBase
    {
        public long IdStorageServer { set; get; }
        public long StorageTypeID { set; get; }

        public string ControllerName { set; get; } = "";

        public string StorageName { set; get; } = "";

        public ICollection<ValidationDomain> ValidationDomains { set; get; } = new List<ValidationDomain>();

        public int Size { set; get; };
        public string IpPublic { set; get; } = "";

        public string IpPrivatev4 { set; get; } = "";

        public string IpPrivatev6 { set; get; } = "";

        public string OsName { set; get; } = "";

        public string OsPlatform { set; get; } = "";

        public string OsVersion { set; get; } = "";

        public string OsKernel { set; get; } = "";

        public string OsArch { set; get; } = "";

        public string BiosSN { set; get; } = "";
        public string BiosVendor { set; get; } = "";

        public string BiosUUID { set; get; } = "";

        public int SocketN { set; get; }

        public string CpuName { set; get; } = "";

        public float TotalRam { set; get; }

        public string TokenID { set; get; } = "";

        public string TokenValue { set; get; } = "";

        public string RTokenID { set; get; } = "";

        public string RTokenValue { set; get; } = "";

        public async Task<IActionResult> GetStorages(int status = 0)
        {
            await using (var con = new MySqlConnection(DBManagement.GetConnectionString()))
            {
                string sql = @"
                        WITH d AS ( 
                            SELECT *
                            FROM StorageServer 
                            WHERE status = @status 
                            ORDER BY idStorageServer 
                            LIMIT @PageSize OFFSET @Offset)
                        SELECT d.*,t.typeName FROM d 
                        JOIN TypeStorageServer t ON t.idTypeStorageServer = d.idTypeStorageServer;
                ";
                await con.OpenAsync();
                if (IsFirstQuery)
                {
                    await using (var multi = await con
                    .QueryMultipleAsync("SELECT COUNT(*) FROM StorageServer;" + sql, new { Offset = (PageNumber - 1) * PageSize, PageSize = this.PageSize, status = status }))
                    {
                        int maxRow = await multi.ReadSingleAsync<int>();
                        var types = await multi.ReadAsync();
                        return new JsonResult(new
                        {
                            mrows = maxRow,
                            data = JsonConvert.SerializeObject(types)
                        });
                    }
                }
                else
                {
                    var t = (await con.QueryAsync(sql, new { Offset = (PageNumber - 1) * PageSize, PageSize = this.PageSize, status = status }));
                    return new JsonResult(new
                    {
                        data = JsonConvert.SerializeObject(t)
                    });
                }
            }
        }
        public override async Task<MessageHeader> AddAsync()
        {
            await using var con = new MySqlConnector.MySqlConnection(DBManagement.GetConnectionString(true));

            await con.OpenAsync();
            var trans = await con.BeginTransactionAsync();
            var f = new MessageHeader();
            try
            {
                var localServer = new LocalServer
                {
                    IpPrivateServer = IpPrivatev4,
                    IpPrivateServerv6 = IpPrivatev6,
                    IpPublicServer = IpPublic,
                    PathServer = "",
                    SerialNumber = BiosSN,
                    OsVersion = OsVersion,
                    OsName = OsName,
                    OsArch = OsArch,
                    OsKernal = OsKernel,
                    SocketNum = SocketN,
                    CpuName = CpuName,
                    TotalRam = TotalRam,
                    BiosVender = BiosVendor,
                    ProductUuid = BiosUUID,
                    Status = 0
                };//idTypeStorageServer
                var storageServer = new StorageServer
                {
                    IdEmp = null,
                    IdTypeStorageServer = StorageTypeID,
                    StorageName = StorageName,
                    CreateDate = DateTime.UtcNow,
                    ControllerID = ControllerName,
                    Status = 0
                };
                var ss_lc = new StorageServer_has_LocalServer
                {
                    IdStorageServer = storageServer.IdStorageServer,
                    IdLocalServer = localServer.IdLocalServer,
                    CreateDate = DateTime.UtcNow,
                    ModifyDate = null,
                    Status = 0
                };

                var serverAuthorization = new ServerAuthorization
                {
                    IdStorageServer = storageServer.IdStorageServer,
                    CreateDate = DateTime.UtcNow,
                    Count = 1,
                    Status = 0
                };  
                var token = new Token
                {
                    IdToken = TokenID,
                    AccessToken = TokenValue,
                    CreateDate = DateTime.UtcNow,
                    ExpireDate = DateTime.UtcNow.AddMonths(3),
                    Status = 0
                };
                var ssAT = new ServerAuthorization_has_Token
                {
                    IdToken = TokenID,
                    Count = 1,
                    Status = 0
                };
                var rT = new RefreshToken
                {
                    IdRefreshToken = RTokenID,
                    IdServerAuthorization = serverAuthorization.IdServerAuthorization,
                    __RefreshToken = RTokenValue,
                    CreateDate = DateTime.UtcNow,
                    ExpireDate = DateTime.UtcNow.AddMonths(9),
                    Status = 0
                };
                BatchInsert bi = new BatchInsert(con, trans);
                bi.AddRow(localServer);
                bi.AddRow(storageServer);
                bi.AddRow(ss_lc);
                bi.AddRow(serverAuthorization);
                bi.AddRow(token);
                bi.AddRow(ssAT);
                bi.AddRow(rT);
                await bi.ExcuteQuery();
                await trans.CommitAsync();
                f.Status = 1;
                f.Message = "OK";
            }
            catch (DbException ex)
            {
                await trans.RollbackAsync();
                await trans.DisposeAsync();
                f.Status = 0;
                f.Message = ex.Message;
                f.ID = 61031;
            }
            return f;
        }

        public override Task<MessageHeader> DeleteAsync()
        {
            throw new NotImplementedException();
        }

        public override Task<MessageHeader> UpdateAsync()
        {
            throw new NotImplementedException();
        }

        public async Task<MessageHeader> UpdateStorageSize()
        {
            var fMess = new MessageHeader();
            string sql = @"UPDATE StorageServer
                           SET Size = @size
                           Where idStorageServer = @idStorage;
                           WITH sa_need AS (
                              SELECT idServerAuthorization
                              FROM ServerAuthorization
                              WHERE idStorageServer = @idStorage
                            ),
                            maxc AS (
                              SELECT idServerAuthorization, MAX(`count`) AS max_count
                              FROM ServerAuthorization_has_Token
                              WHERE idServerAuthorization IN (SELECT idServerAuthorization FROM sa_need)
                              GROUP BY idServerAuthorization
                            )
                            SELECT
                              sa.idServerAuthorization,
                              st.idToken,
                              t.accessToken
                            FROM sa_need sa
                            JOIN maxc m ON m.idServerAuthorization = sa.idServerAuthorization
                            JOIN ServerAuthorization_has_Token st 
                            ON st.idServerAuthorization = sa.idServerAuthorization AND st.`count` = m.max_count
                            LEFT JOIN Token t ON t.idToken = st.idToken;
                            WITH sa_need AS (
                              SELECT idServerAuthorization
                              FROM ServerAuthorization
                              WHERE idStorageServer = @idStorage)
                            SELECT r.*
                            FROM sa_need s
                            JOIN RefreshToken r
                              ON r.idServerAuthorization = s.idServerAuthorization
                            WHERE r.idRefreshToken = (
                              SELECT r2.idRefreshToken
                              FROM RefreshToken r2
                              WHERE r2.idServerAuthorization = s.idServerAuthorization and r2.status = 0
                              ORDER BY r2.expireDate DESC
                              LIMIT 1);";
            try
            {
                await using var con = new MySqlConnection(DBManagement.GetConnectionString(true));
                await con.OpenAsync();
                using var trans = await con.BeginTransactionAsync();
                using var multi = await con.QueryMultipleAsync(sql, new { size = Size, id = IdStorageServer }, trans);
                IList<dynamic> tokens = (await multi.ReadAsync()).AsList();
                IList<dynamic> rTokens = (await multi.ReadAsync()).AsList();
                using (var writer = new StreamWriter(Path.GetFullPath("Json/dataServer.json"), false))
                {
                    await writer.WriteAsync(JsonConvert.SerializeObject(new
                    {
                        idRToken = "",
                        rToken = "",
                        cDate = "",
                        eDate = "",
                        token = "",
                        idToken = ""
                    }));
                }
            }
            catch (DbException ex)
            {

            }
            return fMess;
        }
    }
}