/*
 * @project: TERA
 * @version: Development (beta)
 * @license: MIT (not for evil)
 * @copyright: Yuriy Ivanov (Vtools) 2017-2019 [progr76@gmail.com]
 * Web: https://terafoundation.org
 * Twitter: https://twitter.com/terafoundation
 * Telegram:  https://t.me/terafoundation
*/

"use strict";
require("./library.js");
require("./crypto-library");
require("./terahashmining");
const crypto = require('crypto');
const os = require('os');
global.glStopNode = false;
const MAX_TIME_NETWORK_TRANSPORT = 1 * 1000;
var GlSumUser;
var GlSumSys;
var GlSumIdle;
global.CountAllNode = 0;
module.exports = class CCommon
{
    constructor(SetKeyPair, RunIP, RunPort, UseRNDHeader, bVirtual)
    {
        global.SERVER = this
        this.VirtualMode = bVirtual
        this.KeyPair = SetKeyPair
        var PubKey = SetKeyPair.getPublicKey('', 'compressed');
        this.PubKeyType = PubKey[0]
        this.addrArr = PubKey.slice(1)
        this.addrStr = GetHexFromArr(this.addrArr)
        this.HashDBArr = shaarr2(this.KeyPair.getPrivateKey(), [0, 0, 0, 0, 0, 0, 0, 1])
        this.ServerSign = []
    }
    AddStatOnTimer()
    {
        var CountAll = 0;
        var CurTime = GetCurrentTime() - 0;
        for(var i = 0; i < this.NodesArr.length; i++)
        {
            var Item = this.NodesArr[i];
            if(Item.LastTime && (CurTime - Item.LastTime) < NODES_DELTA_CALC_HOUR * 3600 * 1000)
                CountAll++
            else
                if(Item.LastTimeGetNode && (CurTime - Item.LastTimeGetNode) < NODES_DELTA_CALC_HOUR * 3600 * 1000)
                    CountAll++
        }
        global.CountAllNode = CountAll
        if(!global.STAT_MODE)
            return ;
        var StateTX = DApps.Accounts.DBStateTX.Read(0);
        if(StateTX)
        {
            var Delta = this.CurrentBlockNum - StateTX.BlockNum;
            ADD_TO_STAT("MAX:DELTA_TX", Delta)
        }
        var bHasCP = 0;
        if(CHECK_POINT.BlockNum)
        {
            var Block = this.ReadBlockHeaderDB(CHECK_POINT.BlockNum);
            if(Block && CompareArr(CHECK_POINT.Hash, Block.Hash) === 0)
                bHasCP = 1
        }
        var MinVer = global.MIN_VER_STAT;
        if(MinVer === 0)
            MinVer = global.UPDATE_CODE_VERSION_NUM
        var BufMap = {}, BufMap2 = {};
        var arr = this.GetActualNodes();
        var Count = 0, CountHot = 0, CountHotOK = 0, CountActualOK = 0, SumDeltaHot = 0, SumDeltaActual = 0, CountCP = 0, CountLH = 0,
        CountHash = 0, CountVer = 0, CountStop = 0;
        var CountAutoCorrectTime = 0;
        var SumAvgDeltaTime = 0;
        for(var i = 0; i < arr.length; i++)
        {
            var Node = arr[i];
            if(!Node || Node.IsAddrList)
                continue;
            var INFO = Node.INFO;
            if(!INFO)
                INFO = {}
            if(bHasCP && CHECK_POINT.BlockNum && INFO.CheckPointHashDB && CompareArr(CHECK_POINT.Hash, INFO.CheckPointHashDB) === 0)
            {
                CountCP++
            }
            if(INFO.LoadHistoryMode)
                CountLH++
            if(Node.StopGetBlock)
                CountStop++
            Count++
            SumAvgDeltaTime += Node.DeltaGlobTime
            if(Node.VersionNum >= MinVer)
                CountVer++
            if(INFO && INFO.BlockNumDB && INFO.BlockNumDB <= this.BlockNumDB)
            {
                var HashDB = ReadHashFromBufDB(BufMap2, INFO.BlockNumDB);
                if(HashDB && CompareArr(HashDB, INFO.HashDB) === 0)
                    CountHash++
            }
            var StrChk = GetCheckAccHash(BufMap, INFO.AccountBlockNum, INFO.AccountsHash);
            var Chck = 0;
            if(StrChk.indexOf("=OK=") >= 0)
            {
                Chck = 1
            }
            var DeltaTime = Node.DeltaTime;
            if(!DeltaTime)
                DeltaTime = 0
            CountActualOK += Chck
            SumDeltaActual += DeltaTime
            if(Node.Hot)
            {
                CountHot++
                CountHotOK += Chck
                SumDeltaHot += DeltaTime
            }
            if(INFO.AutoCorrectTime)
                CountAutoCorrectTime++
        }
        ADD_TO_STAT("MAX:ALL_NODES", CountAll)
        ADD_TO_STAT("MAX:CONNECTED_NODES", Count)
        ADD_TO_STAT("MAX:HOT_NODES", CountHot)
        ADD_TO_STAT("MAX:HOT_OK", CountHotOK)
        ADD_TO_STAT("MAX:ACTUAL_OK", CountActualOK)
        ADD_TO_STAT("MAX:CHECK_POINT_OK", CountCP)
        ADD_TO_STAT("MAX:COUNTLH", CountLH)
        ADD_TO_STAT("MAX:HASH_OK", CountHash)
        ADD_TO_STAT("MAX:MIN_VERSION", CountVer)
        ADD_TO_STAT("MAX:STOP_GET", CountStop)
        ADD_TO_STAT("MAX:AUTOCORRECT", CountAutoCorrectTime)
        ADD_TO_STAT("MAX:TIME_DELTA", DELTA_CURRENT_TIME)
        if(!Count)
            Count = 1
        if(!CountHot)
            CountHot = 1
        if(Count >= 20)
        {
            var SumDeltaAvg = 0;
            var AvgGlobTime = SumAvgDeltaTime / Count;
            for(var i = 0; i < arr.length; i++)
            {
                var Node = arr[i];
                if(!Node || Node.IsAddrList)
                    continue;
                var Delta = AvgGlobTime - Node.DeltaGlobTime;
                SumDeltaAvg += Delta * Delta
            }
            SumDeltaAvg = Math.sqrt(SumDeltaAvg / Count)
            ADD_TO_STAT("MAX:DELTA_GLOB_TIME", 100 + AvgGlobTime)
            ADD_TO_STAT("MAX:DISP_DELTA_GLOB_TIME", SumDeltaAvg)
            arr.sort(function (a,b)
            {
                return a.DeltaGlobTime - b.DeltaGlobTime;
            })
            var SumDeltaAvgM = 0;
            var AvgGlobTimeM = arr[Math.trunc(arr.length / 2)].DeltaGlobTime;
            var Length = arr.length;
            var Start = Math.trunc(Length * 0.05);
            var End = Math.trunc(Length * 0.95);
            var NodesCount = 0;
            for(var i = Start; i < End; i++)
            {
                var Node = arr[i];
                if(!Node || Node.IsAddrList)
                    continue;
                NodesCount++
                var Delta = AvgGlobTimeM - Node.DeltaGlobTime;
                SumDeltaAvgM += Delta * Delta
            }
            if(!NodesCount)
                NodesCount = 1
            SumDeltaAvgM = Math.sqrt(SumDeltaAvgM / NodesCount)
            ADD_TO_STAT("MAX:MEDIAN_GLOB_TIME", 100 + AvgGlobTimeM)
            ADD_TO_STAT("MAX:DISP_MEDIAN_GLOB_TIME", SumDeltaAvgM)
        }
        ADD_TO_STAT("MAX:DELTA_TIME_HOT", SumDeltaHot / CountHot)
        ADD_TO_STAT("MAX:DELTA_TIME_ACTUAL", SumDeltaActual / Count)
        ADD_TO_STAT("MAX:MEMORY_USAGE", process.memoryUsage().heapTotal / 1024 / 1024)
        ADD_TO_STAT("MAX:MEMORY_FREE", os.freemem() / 1024 / 1024)
        var SumUser = 0;
        var SumSys = 0;
        var SumIdle = 0;
        var cpus = os.cpus();
        for(var i = 0; i < cpus.length; i++)
        {
            var cpu = cpus[i];
            SumUser += cpu.times.user
            SumSys += cpu.times.sys + cpu.times.irq
            SumIdle += cpu.times.idle
        }
        if(GlSumUser !== undefined)
        {
            var maxsum = cpus.length * 1000;
            ADD_TO_STAT("MAX:CPU_USER_MODE", Math.min(maxsum, SumUser - GlSumUser))
            ADD_TO_STAT("MAX:CPU_SYS_MODE", Math.min(maxsum, SumSys - GlSumSys))
            ADD_TO_STAT("MAX:CPU_IDLE_MODE", Math.min(maxsum, SumIdle - GlSumIdle))
            ADD_TO_STAT("MAX:CPU", Math.min(maxsum, SumUser + SumSys - GlSumUser - GlSumSys))
        }
        GlSumUser = SumUser
        GlSumSys = SumSys
        GlSumIdle = SumIdle
    }
    GetNewMeta()
    {
        return crypto.randomBytes(32);
    }
};
class SMemBuffer
{
    constructor(MaxTime, CheckName)
    {
        this.MetaMap1 = {}
        this.MetaMap2 = {}
        this.CheckName = CheckName
        setInterval(this.ShiftMapDirect.bind(this), MaxTime)
    }
    GetStrKey(Arr)
    {
        if(typeof Arr === "number" || typeof Arr === "string")
        {
            return Arr;
        }
        else
        {
            return GetHexFromAddres(Arr);
        }
        throw "NOT RET!";
    }
    LoadValue(Arr, bStay)
    {
        if(!Arr)
            return undefined;
        var Key = this.GetStrKey(Arr);
        var Value = this.MetaMap1[Key];
        if(Value !== undefined)
        {
            if(!bStay)
                delete this.MetaMap1[Key]
            return Value;
        }
        Value = this.MetaMap2[Key]
        if(Value !== undefined)
        {
            if(!bStay)
                delete this.MetaMap2[Key]
        }
        return Value;
    }
    SaveValue(Arr, Value)
    {
        var Key = this.GetStrKey(Arr);
        if(Value !== undefined)
            this.MetaMap1[Key] = Value
    }
    ShiftMapDirect()
    {
        if(glStopNode)
            return ;
        if(this.CheckName)
        {
            var Count = 0;
            for(var key in this.MetaMap2)
            {
                Count++
            }
            if(Count)
            {
                ADD_TO_STAT(this.CheckName, 1, 1)
            }
        }
        this.MetaMap2 = this.MetaMap1
        this.MetaMap1 = {}
    }
    Clear()
    {
        this.MetaMap2 = {}
        this.MetaMap1 = {}
    }
};
class STreeBuffer
{
    constructor(MaxTime, CompareFunction, KeyType, CheckName)
    {
        this.KeyType = KeyType
        this.MetaTree1 = new RBTree(CompareFunction)
        this.MetaTree2 = new RBTree(CompareFunction)
        this.CheckName = CheckName
        setInterval(this.ShiftMapDirect.bind(this), MaxTime)
    }
    LoadValue(Hash, bStay)
    {
        if(!Hash)
            return undefined;
        if(typeof Hash !== this.KeyType)
            throw "MUST ONLY HASH ARRAY: " + Hash;
        var element = this.MetaTree1.find({hash:Hash});
        if(element)
        {
            if(!bStay)
                this.MetaTree1.remove(element)
            return element.value;
        }
        element = this.MetaTree2.find({hash:Hash})
        if(element)
        {
            if(!bStay)
                this.MetaTree2.remove(element)
            return element.value;
        }
        return undefined;
    }
    SaveValue(Hash, Value)
    {
        if(typeof Hash !== this.KeyType)
            throw "MUST ONLY TYPE=" + this.KeyType + " in " + Hash;
        if(Value !== undefined)
        {
            var element = this.MetaTree1.find({hash:Hash});
            if(element)
                element.value = Value
            else
                this.MetaTree1.insert({hash:Hash, value:Value})
        }
    }
    ShiftMapDirect()
    {
        if(this.CheckName && this.MetaTree2.size)
        {
            ADD_TO_STAT(this.CheckName, this.MetaTree2.size, 1)
            var it = this.MetaTree2.iterator(), Item;
            while((Item = it.next()) !== null)
            {
                var Name = Item.value.Name;
                ADD_TO_STAT(this.CheckName + ":" + Name, 1, 1)
            }
        }
        this.MetaTree2.clear()
        var empty_tree = this.MetaTree2;
        this.MetaTree2 = this.MetaTree1
        this.MetaTree1 = empty_tree
    }
    Clear()
    {
        this.MetaTree1.clear()
        this.MetaTree2.clear()
    }
};

function ReadHashFromBufDB(Map,BlockNum)
{
    var MyHash = Map[BlockNum];
    if(!MyHash)
    {
        var Block = SERVER.ReadBlockHeaderDB(BlockNum);
        if(Block)
            MyHash = Block.Hash;
        else
            MyHash = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
        Map[BlockNum] = MyHash;
    }
    return MyHash;
};

function GetCheckAccHash(Map,BlockNum,Hash)
{
    var MyHash = Map[BlockNum];
    if(!MyHash)
    {
        MyHash = DApps.Accounts.GetHashOrUndefined(BlockNum);
        Map[BlockNum] = MyHash;
    }
    if(MyHash)
    {
        if(!Hash)
            return "=ERR:NO=";
        if(CompareArr(Hash, MyHash) !== 0)
            return "=ERR:BAD=";
        else
            return "=OK=";
    }
    else
    {
        if(!Hash)
            return "=OK=:NO";
        else
            return "=MY:NO=";
    }
};
global.GetCheckAccHash = GetCheckAccHash;
global.ReadHashFromBufDB = ReadHashFromBufDB;
global.STreeBuffer = STreeBuffer;
global.TestCreateTr = TestCreateTr;

function TestCreateTr()
{
    const FORMAT_CREATE = "{\
        Type:byte,\
        Currency:uint,\
        PubKey:arr33,\
        Description:str40,\
        Adviser:uint,\
        Reserve:arr7,\
        POWCreate:arr12,\
        }";
    var TR = {Type:100, Currency:0, PubKey:[2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0], Description:"Description", Adviser:10, };
    var Body = BufLib.GetBufferFromObject(TR, FORMAT_CREATE, 1000, {});
    var startTime = process.hrtime();
    var StartData = Date.now();
    var nonce = CreateHashBodyPOWInnerMinPower(Body, 1000, 17);
    var Time = process.hrtime(startTime);
    var power = GetPowPower(shaarr(Body));
    var deltaTime = (Time[0] * 1000 + Time[1] / 1e6) / 1000;
    var DeltaData = (new Date() - StartData) / 1000;
    ToLog("power=" + power + "  nonce=" + nonce + " TIME=" + deltaTime + " sec" + "  DeltaData=" + DeltaData + " sec");
    return {time1:deltaTime, time2:DeltaData};
};

function CreateHashBody(body,Num,Nonce)
{
    body.writeUIntLE(Num, body.length - 12, 6);
    body.writeUIntLE(Nonce, body.length - 6, 6);
    return shaarr(body);
};

function CreateHashBodyPOWInnerMinPower(arr,BlockNum,MinPow)
{
    var nonce = 0;
    while(1)
    {
        var arrhash = CreateHashBody(arr, BlockNum, nonce);
        var power = GetPowPower(arrhash);
        if(power >= MinPow)
        {
            return nonce;
        }
        nonce++;
    }
};