/*
 * @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("./crypto-library");
require("./log.js");
const crypto = require('crypto');
const os = require('os');
var BlockTree = new STreeBuffer(300 * 1000, CompareItemHashSimple, "number");
const http = require('http'), net = require('net'), url = require('url'), fs = require('fs'), querystring = require('querystring');
var ContenTypeMap = {};
ContenTypeMap["js"] = "application/javascript";
ContenTypeMap["css"] = "text/css";
ContenTypeMap["wav"] = "audio/wav";
ContenTypeMap["mp3"] = "audio/mpeg";
ContenTypeMap["mp4"] = "video/mp4";
ContenTypeMap["ico"] = "image/vnd.microsoft.icon";
ContenTypeMap["jpg"] = "image/jpeg";
ContenTypeMap["png"] = "image/png";
ContenTypeMap["gif"] = "image/gif";
ContenTypeMap["html"] = "text/html";
ContenTypeMap["txt"] = "text/plain";
ContenTypeMap["csv"] = "text/csv";
ContenTypeMap["svg"] = "image/svg+xml";
ContenTypeMap["zip"] = "application/zip";
ContenTypeMap["pdf"] = "application/pdf";
ContenTypeMap["exe"] = "application/octet-stream";
ContenTypeMap["msi"] = "application/octet-stream";
ContenTypeMap["woff"] = "application/font-woff";
var DefaultContentType = "application/octet-stream";
ContenTypeMap["psd"] = "application/octet-stream";
global.HTTPCaller = {};

function DoCommand(response,Type,Path,params,remoteAddress)
{
    var F = HTTPCaller[params[0]];
    if(F)
    {
        if(Type !== "POST")
        {
            response.end();
            return ;
        }
        response.writeHead(200, {'Content-Type':'text/plain'});
        var Ret = F(params[1], response);
        if(Ret === null)
            return ;
        try
        {
            var Str = JSON.stringify(Ret);
            response.end(Str);
        }
        catch(e)
        {
            ToLog("ERR PATH:" + Path);
            ToLog(e);
            response.end();
        }
        return ;
    }
    var method = params[0];
    method = method.toLowerCase();
    if(method === "dapp" && params.length === 2)
        method = "DappTemplateFile";
    switch(method)
    {
        case "":
            SendWebFile(response, "./HTML/wallet.html");
            break;
        case "file":
            SendBlockFile(response, params[1], params[2]);
            break;
        case "DappTemplateFile":
            DappTemplateFile(response, params[1]);
            break;
        case "smart":
            DappSmartCodeFile(response, params[1]);
            break;
        case "client":
            DappClientCodeFile(response, params[1]);
            break;
        default:
            {
                if(Path.indexOf(".") ===  - 1)
                    ToError("Error path:" + Path + "  remoteAddress=" + remoteAddress);
                var path = params[params.length - 1];
                if(typeof path !== "string")
                    path = "ErrorPath";
                else
                    if(path.indexOf("..") >= 0 || path.indexOf("\\") >= 0 || path.indexOf("/") >= 0)
                        path = "ErrorFilePath";
                if(path.indexOf(".") < 0)
                    path += ".html";
                var type = Path.substr(Path.length - 3, 3);
                switch(type)
                {
                    case ".js":
                        path = "./HTML/JS/" + path;
                        break;
                    case "css":
                        path = "./HTML/CSS/" + path;
                        break;
                    case "wav":
                    case "mp3":
                        path = "./HTML/SOUND/" + path;
                        break;
                    case "svg":
                    case "png":
                    case "gif":
                    case "jpg":
                    case "ico":
                        path = "./HTML/PIC/" + path;
                        break;
                    case "pdf":
                    case "zip":
                    case "exe":
                    case "msi":
                        path = "./HTML/FILES/" + path;
                        break;
                    default:
                        path = "./HTML/" + path;
                        break;
                }
                SendWebFile(response, path, Path);
                break;
            }
    }
};
global.DappTemplateFile = DappTemplateFile;

function DappTemplateFile(response,StrNum)
{
    var Num = parseInt(StrNum);
    if(Num && Num <= DApps.Smart.GetMaxNum())
    {
        var Data = DApps.Smart.ReadSmart(Num);
        if(Data)
        {
            response.writeHead(200, {'Content-Type':'text/html', "X-Frame-Options":"sameorigin"});
            var Str = fs.readFileSync("HTML/dapp-frame.html", {encoding:"utf8"});
            Str = Str.replace(/#template-number#/g, StrNum);
            Str = Str.replace(/DAPP Loading.../g, Data.Name);
            Str = Str.replace(/.\/tera.ico/g, "/file/" + Data.IconBlockNum + "/" + Data.IconTrNum);
            response.end(Str);
            return ;
        }
    }
    response.writeHead(404, {'Content-Type':'text/html'});
    response.end();
};
global.DappSmartCodeFile = DappSmartCodeFile;

function DappSmartCodeFile(response,StrNum)
{
    var Num = parseInt(StrNum);
    if(Num && Num <= DApps.Smart.GetMaxNum())
    {
        var Data = DApps.Smart.ReadSmart(Num);
        if(Data)
        {
            response.writeHead(200, {'Content-Type':'application/javascript'});
            response.end(Data.Code);
            return ;
        }
    }
    response.writeHead(404, {'Content-Type':'text/html'});
    response.end();
};
global.DappClientCodeFile = DappClientCodeFile;

function DappClientCodeFile(response,StrNum)
{
    var Num = parseInt(StrNum);
    if(Num && Num <= DApps.Smart.GetMaxNum())
    {
        var Data = DApps.Smart.ReadSmart(Num);
        if(Data)
        {
            response.writeHead(200, {'Content-Type':"text/plain"});
            response.end(Data.HTML);
            return ;
        }
    }
    response.writeHead(404, {'Content-Type':'text/html'});
    response.end();
};
HTTPCaller.DappSmartHTMLFile = function (Params)
{
    var Data = DApps.Smart.ReadSmart(ParseNum(Params.Smart));
    if(Data)
    {
        if(global.DEV_MODE && Params.DebugPath)
        {
            ToLog("Load: " + Params.DebugPath);
            Data.HTML = fs.readFileSync(Params.DebugPath, {encoding:"utf8"});
        }
        return {result:1, Body:Data.HTML};
    }
    return {result:0};
};
global.SendBlockFile = SendBlockFile;

function SendBlockFile(response,BlockNum,TrNum)
{
    BlockNum = parseInt(BlockNum);
    TrNum = parseInt(TrNum);
    if(BlockNum && BlockNum <= SERVER.GetMaxNumBlockDB() && TrNum <= MAX_TRANSACTION_COUNT)
    {
        var Block = SERVER.ReadBlockDB(BlockNum);
        if(Block && Block.arrContent)
        {
            SendToResponceFile(response, Block, TrNum);
            return ;
        }
        else
            if(!Block || !Block.TrDataPos)
            {
                LoadBlockFromNetwork({BlockNum:BlockNum}, function (Err,Block)
                {
                    if(Err)
                    {
                        SendToResponce404(response);
                    }
                    else
                    {
                        SendToResponceFile(response, Block, TrNum);
                    }
                });
                return ;
            }
    }
    SendToResponce404(response);
};

function SendToResponceFile(response,Block,TrNum)
{
    var Body = Block.arrContent[TrNum];
    if(Body && Body.data)
        Body = Body.data;
    if(Body && Body[0] === global.TYPE_TRANSACTION_FILE)
    {
        var TR = DApps.File.GetObjectTransaction(Body);
        if(TR.ContentType.toLowerCase().indexOf("html") >= 0)
            response.writeHead(200, {'Content-Type':"text/plain"});
        else
            response.writeHead(200, {'Content-Type':TR.ContentType});
        response.end(TR.Data);
    }
    else
    {
        SendToResponce404(response);
    }
};

function SendToResponce404(response)
{
    response.writeHead(404, {'Content-Type':'text/html'});
    response.end();
};
HTTPCaller.DappBlockFile = function (Params,response)
{
    Params.BlockNum = ParseNum(Params.BlockNum);
    Params.TrNum = ParseNum(Params.TrNum);
    if(!Params.TrNum)
        Params.TrNum = 0;
    if(Params.BlockNum && Params.BlockNum <= SERVER.GetMaxNumBlockDB() && Params.TrNum <= MAX_TRANSACTION_COUNT)
    {
        var Block = SERVER.ReadBlockDB(Params.BlockNum);
        if(Block && Block.arrContent)
        {
            SendToResponceDappFile(response, Block, Params.TrNum);
            return null;
        }
        else
            if(!Block || !Block.TrDataPos)
            {
                LoadBlockFromNetwork(Params, function (Err,Block)
                {
                    if(Err)
                    {
                        SendToResponceResult0(response);
                    }
                    else
                    {
                        SendToResponceDappFile(response, Block, Params.TrNum);
                    }
                });
                return null;
            }
    }
    return {result:0};
};

function SendToResponceDappFile(response,Block,TrNum)
{
    var Result = {result:0};
    var Body = Block.arrContent[TrNum];
    if(Body)
    {
        var Type = Body[0];
        if(Type === global.TYPE_TRANSACTION_FILE)
        {
            var TR = DApps.File.GetObjectTransaction(Body);
            Result = {result:1, Type:Type, ContentType:TR.ContentType, Name:TR.Name, Body:TR.Data.toString('utf8')};
        }
        else
        {
            var App = DAppByType[Type];
            if(App)
            {
                Body = JSON.parse(App.GetScriptTransaction(Body));
            }
            Result = {result:1, Type:Type, Body:Body};
        }
    }
    var Str = JSON.stringify(Result);
    response.end(Str);
};

function SendToResponceResult0(response)
{
    if(response)
        response.end("{\"result\":0}");
};
var glBlock0;
HTTPCaller.DappStaticCall = function (Params,response)
{
    var Result = RunStaticSmartMethod(ParseNum(Params.Account), Params.MethodName, Params.Params);
    var Str = JSON.stringify(Result);
    if(Str.length > 16000)
    {
        return {result:0, RetValue:"Error result length (more 16000)"};
    }
    response.end(Str);
    return null;
    DApps.Accounts.BeginBlock();
    DApps.Accounts.BeginTransaction();
    global.TickCounter = 100000;
    var Account = DApps.Accounts.ReadStateTR(ParseNum(Params.Account));
    if(!Account)
    {
        return {result:0, RetValue:"Error account Num: " + Params.Account};
    }
    if(!glBlock0)
        glBlock0 = SERVER.ReadBlockHeaderDB(0);
    var RetValue;
    try
    {
        var BlockNum = GetCurrentBlockNumByTime();
        RetValue = RunSmartMethod(glBlock0, Account.Value.Smart, Account, BlockNum, 0, undefined, Params.MethodName, Params.Params,
        1);
    }
    catch(e)
    {
        return {result:0, RetValue:"" + e};
    }
    var Str = JSON.stringify({result:1, RetValue:RetValue});
    if(Str.length > 16000)
    {
        return {result:0, RetValue:"Error result length (more 16000)"};
    }
    response.end(Str);
    return null;
};
HTTPCaller.DappInfo = function (Params,responce,ObjectOnly)
{
    var SmartNum = ParseNum(Params.Smart);
    if(global.TX_PROCESS && global.TX_PROCESS.Worker)
        global.TX_PROCESS.Worker.send({cmd:"SetSmartEvent", Smart:SmartNum});
    var Account;
    var Smart = DApps.Smart.ReadSimple(SmartNum);
    if(Smart)
    {
        delete Smart.HTML;
        delete Smart.Code;
        Account = DApps.Accounts.ReadState(Smart.Account);
        try
        {
            Account.SmartState = BufLib.GetObjectFromBuffer(Account.Value.Data, Smart.StateFormat, {});
            if(typeof Account.SmartState === "object")
                Account.SmartState.Num = Account.Num;
        }
        catch(e)
        {
            if(!Account)
                Account = {};
            Account.SmartState = {};
        }
    }
    DeleteOldEvents(SmartNum);
    var Context = GetUserContext(Params);
    var EArr = GetEventArray(SmartNum, Context);
    var WLData = HTTPCaller.DappWalletList(Params);
    var ArrLog = [];
    for(var i = 0; i < ArrLogClient.length; i++)
    {
        var Item = ArrLogClient[i];
        if(!Item.final)
            continue;
        ArrLog.push(Item);
    }
    var Ret = {result:1, DELTA_CURRENT_TIME:DELTA_CURRENT_TIME, MIN_POWER_POW_TR:MIN_POWER_POW_TR, FIRST_TIME_BLOCK:FIRST_TIME_BLOCK,
        CONSENSUS_PERIOD_TIME:CONSENSUS_PERIOD_TIME, PRICE_DAO:PRICE_DAO(SERVER.BlockNumDB), NEW_SIGN_TIME:NEW_SIGN_TIME, Smart:Smart,
        Account:Account, NETWORK:global.NETWORK, ArrWallet:WLData.arr, ArrEvent:EArr, ArrLog:ArrLog, };
    if(global.WALLET)
    {
        Ret.WalletIsOpen = (WALLET.WalletOpen !== false);
        Ret.WalletCanSign = (WALLET.WalletOpen !== false && WALLET.KeyPair.WasInit);
        Ret.PubKey = WALLET.KeyPair.PubKeyStr;
    }
    if(!ObjectOnly)
    {
        Ret.CurTime = Date.now();
        Ret.CurBlockNum = GetCurrentBlockNumByTime();
        Ret.MaxAccID = DApps.Accounts.GetMaxAccount();
        Ret.MaxDappsID = DApps.Smart.GetMaxNum();
    }
    return Ret;
};
HTTPCaller.DappWalletList = function (Params)
{
    var arr0 = DApps.Accounts.GetWalletAccountsByMap(WALLET.AccountMap);
    var arr = [];
    for(var i = 0; i < arr0.length; i++)
    {
        if(Params.AllAccounts || arr0[i].Value.Smart === Params.Smart)
        {
            arr.push(arr0[i]);
        }
    }
    var Ret = {result:1, arr:arr, };
    return Ret;
};
HTTPCaller.DappAccountList = function (Params)
{
    var arr = DApps.Accounts.GetRowsAccounts(Params.StartNum, Params.CountNum, undefined, 1);
    return {arr:arr, result:1};
};
HTTPCaller.DappSmartList = function (Params)
{
    var arr = DApps.Smart.GetRows(Params.StartNum, Params.CountNum, undefined, undefined, Params.GetAllData, Params.TokenGenerate);
    return {arr:arr, result:1};
};
HTTPCaller.DappBlockList = function (Params,response)
{
    Params.Filter = undefined;
    return HTTPCaller.GetBlockList(Params, response, 1);
};
HTTPCaller.DappTransactionList = function (Params,response)
{
    Params.Filter = undefined;
    Params.Param3 = Params.BlockNum;
    return HTTPCaller.GetTransactionAll(Params, response);
};
var sessionid = GetHexFromAddres(crypto.randomBytes(20));
HTTPCaller.RestartNode = function (Params)
{
    global.RestartNode();
    return {result:1};
};
HTTPCaller.ToLogServer = function (Str)
{
    ToLogClient(Str);
    return {result:1};
};
HTTPCaller.FindMyAccounts = function (Params)
{
    WALLET.FindMyAccounts(1);
    return {result:1};
};
HTTPCaller.GetAccount = function (id)
{
    id = parseInt(id);
    var arr = DApps.Accounts.GetRowsAccounts(id, 1);
    return {Item:arr[0], result:1};
};
HTTPCaller.GetAccountList = function (Params)
{
    if(!Params.CountNum)
        Params.CountNum = 1;
    var arr = DApps.Accounts.GetRowsAccounts(Params.StartNum, Params.CountNum, Params.Filter);
    return {arr:arr, result:1};
};
HTTPCaller.GetDappList = function (Params)
{
    if(!Params.CountNum)
        Params.CountNum = 1;
    var arr = DApps.Smart.GetRows(Params.StartNum, Params.CountNum, Params.Filter, Params.Filter2, 1);
    return {arr:arr, result:1};
};
HTTPCaller.GetBlockList = function (Params,response,bOnlyNum)
{
    if(!Params.CountNum)
        Params.CountNum = 1;
    if(Params.StartNum < SERVER.BlockNumDBMin)
    {
        let CountWait = 0;
        var WasWait = 0;
        for(var BlockNum = Params.StartNum; BlockNum < Params.StartNum + Params.CountNum; BlockNum++)
        {
            var Block = SERVER.ReadBlockHeaderDB(BlockNum);
            if(!Block)
            {
                CountWait++;
                WasWait = 1;
                LoadBlockFromNetwork({BlockNum:BlockNum}, function (Err,Block)
                {
                    CountWait--;
                    if(CountWait === 0)
                    {
                        var arr = SERVER.GetRows(Params.StartNum, Params.CountNum, Params.Filter);
                        var Result = {arr:arr, result:1};
                        response.end(JSON.stringify(Result));
                    }
                });
            }
        }
        if(WasWait)
            return null;
    }
    var arr = SERVER.GetRows(Params.StartNum, Params.CountNum, Params.Filter, !bOnlyNum);
    return {arr:arr, result:1};
};
HTTPCaller.GetTransactionAll = function (Params,response)
{
    if(!Params.CountNum)
        Params.CountNum = 1;
    var BlockNum = Params.Param3;
    if(BlockNum < SERVER.BlockNumDBMin)
    {
        var Block = SERVER.ReadBlockHeaderDB(BlockNum);
        if(!Block)
        {
            LoadBlockFromNetwork({BlockNum:BlockNum}, function (Err,Block)
            {
                var Result;
                if(Err)
                {
                    Result = {arr:[], result:0};
                }
                else
                {
                    var arr = SERVER.GetTrRows(Block.BlockNum, Params.StartNum, Params.CountNum, Params.Filter);
                    Result = {arr:arr, result:1};
                }
                var Str = JSON.stringify(Result);
                response.end(Str);
            });
            return null;
        }
    }
    var arr = SERVER.GetTrRows(BlockNum, Params.StartNum, Params.CountNum, Params.Filter);
    return {arr:arr, result:1};
};
HTTPCaller.GetActList = function (Params)
{
    var arr = DApps.Accounts.GetActList(Params.StartNum, Params.CountNum, Params.Filter);
    return {arr:arr, result:1};
};
HTTPCaller.GetHashList = function (Params)
{
    var arr = DApps.Accounts.DBAccountsHash.GetRows(Params.StartNum, Params.CountNum, Params.Filter);
    for(var i = 0; i < arr.length; i++)
    {
        var item = arr[i];
        item.BlockNum = item.Num * PERIOD_ACCOUNT_HASH;
        item.Hash100 = [];
        if(item.BlockNum % 100 === 0)
        {
            var Data = SERVER.DBHeader100.Read(item.BlockNum / 100);
            if(Data)
                item.Hash100 = Data.Hash100;
        }
    }
    return {arr:arr, result:1};
};
HTTPCaller.GetHistoryAct = function (Params)
{
    var arr = WALLET.GetHistory(Params.StartNum, Params.CountNum, Params.Filter);
    return {arr:arr, result:1};
};
var LastTimeGetHashRate = 0;
var LastHashRate = 0;
var HashRateOneSec = 0;
HTTPCaller.GetWalletInfo = function (Params)
{
    var Constants = {};
    for(var i = 0; i < global.CONST_NAME_ARR.length; i++)
    {
        var key = global.CONST_NAME_ARR[i];
        Constants[key] = global[key];
    }
    var MaxHistory = 0;
    var Delta = Date.now() - LastTimeGetHashRate;
    if(Delta >= 1000)
    {
        if(Delta < 1100)
            HashRateOneSec = global.HASH_RATE - LastHashRate;
        LastHashRate = global.HASH_RATE;
        LastTimeGetHashRate = Date.now();
    }
    var StateTX = DApps.Accounts.DBStateTX.Read(0);
    var TXBlockNum = 0;
    if(StateTX)
        TXBlockNum = StateTX.BlockNum;
    var Ret = {result:1, WalletOpen:WALLET.WalletOpen, WalletIsOpen:(WALLET.WalletOpen !== false), WalletCanSign:(WALLET.WalletOpen !== false && WALLET.KeyPair.WasInit),
        CODE_VERSION:CODE_VERSION, MAX_TRANSACTION_LIMIT:MAX_TRANSACTION_LIMIT, PROTOCOL_VER:PROTOCOL_VER, PROTOCOL_MODE:PROTOCOL_MODE,
        MAX_LEVEL:MAX_LEVEL, VersionNum:global.UPDATE_CODE_VERSION_NUM, RelayMode:SERVER.RelayMode, BlockNumDB:SERVER.BlockNumDB, CurBlockNum:GetCurrentBlockNumByTime(),
        CurTime:Date.now(), IsDevelopAccount:IsDeveloperAccount(WALLET.PubKeyArr), AccountMap:WALLET.AccountMap, ArrLog:ArrLogClient,
        MaxAccID:DApps.Accounts.GetMaxAccount(), MaxActNum:DApps.Accounts.GetActsMaxNum(), MaxDappsID:DApps.Smart.GetMaxNum(), NeedRestart:global.NeedRestart,
        ip:SERVER.ip, port:SERVER.port, NET_WORK_MODE:global.NET_WORK_MODE, INTERNET_IP_FROM_STUN:global.INTERNET_IP_FROM_STUN, HistoryMaxNum:MaxHistory,
        DELTA_CURRENT_TIME:DELTA_CURRENT_TIME, FIRST_TIME_BLOCK:FIRST_TIME_BLOCK, CONSENSUS_PERIOD_TIME:CONSENSUS_PERIOD_TIME, NEW_SIGN_TIME:NEW_SIGN_TIME,
        DATA_PATH:(DATA_PATH.substr(1, 1) === ":" ? DATA_PATH : GetNormalPathString(process.cwd() + "/" + DATA_PATH)), NodeAddrStr:SERVER.addrStr,
        STAT_MODE:global.STAT_MODE, HTTPPort:global.HTTP_PORT_NUMBER, HTTPPassword:HTTP_PORT_PASSWORD, CONSTANTS:Constants, CheckPointBlockNum:CHECK_POINT.BlockNum,
        MiningAccount:global.GENERATE_BLOCK_ACCOUNT, CountMiningCPU:GetCountMiningCPU(), CountRunCPU:global.ArrMiningWrk.length, MiningPaused:global.MiningPaused,
        HashRate:HashRateOneSec, MIN_POWER_POW_TR:MIN_POWER_POW_TR, PRICE_DAO:PRICE_DAO(SERVER.BlockNumDB), NWMODE:global.NWMODE, PERIOD_ACCOUNT_HASH:PERIOD_ACCOUNT_HASH,
        MAX_ACCOUNT_HASH:DApps.Accounts.DBAccountsHash.GetMaxNum(), TXBlockNum:TXBlockNum, SpeedSignLib:global.SpeedSignLib, NETWORK:global.NETWORK,
    };
    if(Params.Account)
        Ret.PrivateKey = GetHexFromArr(WALLET.GetPrivateKey(WALLET.AccountMap[Params.Account]));
    else
        Ret.PrivateKey = GetHexFromArr(WALLET.GetPrivateKey());
    Ret.PublicKey = WALLET.KeyPair.PubKeyStr;
    return Ret;
};
HTTPCaller.GetCurrentInfo = HTTPCaller.GetWalletInfo;
HTTPCaller.TestSignLib = function ()
{
    global.TestSignLib();
};
HTTPCaller.GetWalletAccounts = function ()
{
    var Ret = {result:1, arr:DApps.Accounts.GetWalletAccountsByMap(WALLET.AccountMap), };
    Ret.PrivateKey = WALLET.KeyPair.PrivKeyStr;
    Ret.PublicKey = WALLET.KeyPair.PubKeyStr;
    return Ret;
};
HTTPCaller.SetWalletKey = function (PrivateKeyStr)
{
    WALLET.SetPrivateKey(PrivateKeyStr, true);
    return {result:1};
};
HTTPCaller.SetWalletPasswordNew = function (Password)
{
    WALLET.SetPasswordNew(Password);
    return {result:1};
};
HTTPCaller.OpenWallet = function (Password)
{
    var res = WALLET.OpenWallet(Password);
    return {result:res};
};
HTTPCaller.CloseWallet = function ()
{
    var res = WALLET.CloseWallet();
    return {result:res};
};
HTTPCaller.GetSignTransaction = function (TR)
{
    var Sign = WALLET.GetSignTransaction(TR);
    return {Sign:Sign, result:1};
};
HTTPCaller.GetSignFromHEX = function (Params)
{
    var Arr = GetArrFromHex(Params.Hex);
    var Sign;
    if(Params.Account)
        Sign = WALLET.GetSignFromArr(Arr, WALLET.AccountMap[Params.Account]);
    else
        Sign = WALLET.GetSignFromArr(Arr);
    return {Sign:Sign, result:1};
};
HTTPCaller.SendTransactionHex = function (Params)
{
    var body = GetArrFromHex(Params.Hex);
    var Result = {result:1};
    var Res = SERVER.AddTransactionOwn({body:body, ToAll:1});
    Result.sessionid = sessionid;
    Result.text = AddTrMap[Res];
    var final = false;
    if(Res <= 0 && Res !==  - 3)
        final = true;
    ToLogClient("Send: " + Result.text, GetHexFromArr(sha3(body)), final);
    return Result;
};
HTTPCaller.SendDirectCode = function (Params,response)
{
    var Result;
    if(Params.TX || Params.WEB || Params.ST)
    {
        var RunProcess;
        if(Params.TX)
            RunProcess = global.TX_PROCESS;
        if(Params.WEB)
            RunProcess = global.WEB_PROCESS;
        if(Params.ST)
            RunProcess = global.STATIC_PROCESS;
        if(RunProcess && RunProcess.RunRPC)
        {
            RunProcess.RunRPC("EvalCode", Params.Code, function (Err,Ret)
            {
                Result = {result:!Err, sessionid:sessionid, text:Ret, };
                var Str = JSON.stringify(Result);
                response.end(Str);
            });
            return null;
        }
        else
        {
            Result = "No process for send call";
        }
    }
    else
    {
        try
        {
            var ret = eval(Params.Code);
            Result = JSON.stringify(ret, "", 4);
        }
        catch(e)
        {
            Result = "" + e;
        }
    }
    var Struct = {result:1, sessionid:sessionid, text:Result};
    return Struct;
};
HTTPCaller.SetMining = function (MiningAccount)
{
    WALLET.SetMiningAccount(parseInt(MiningAccount));
    return {result:1};
};

function CheckCorrectDevKey()
{
    if(WALLET.WalletOpen === false)
    {
        var StrErr = "Not open wallet";
        ToLogClient(StrErr);
        return {result:0, text:StrErr};
    }
    if(!IsDeveloperAccount(WALLET.PubKeyArr))
    {
        var StrErr = "Not developer key";
        ToLogClient(StrErr);
        return {result:0, text:StrErr};
    }
    return true;
};
HTTPCaller.SendECode = function (Param)
{
    var Ret = CheckCorrectDevKey();
    if(Ret !== true)
        return Ret;
    if(Param.All)
    {
        SERVER.ConnectToAll();
        var arr = SERVER.GetActualNodes();
        for(var i = 0; i < arr.length; i++)
        {
            var Node = arr[i];
            SERVER.SendECode(Param, Node);
        }
        return {result:1, text:"Sent to " + arr.length + " nodes"};
    }
    var Node = FindNodeByAddr(Param.Addr, 1);
    if(Node === undefined)
        return {result:0, text:"Node not found"};
    if(Node === false)
        return {result:0, text:"Node not active - reconnect"};
    SERVER.SendECode(Param, Node);
    return {result:1, text:"Send"};
};
HTTPCaller.SetCheckPoint = function (BlockNum)
{
    var Ret = CheckCorrectDevKey();
    if(Ret !== true)
        return Ret;
    if(!BlockNum)
        BlockNum = SERVER.BlockNumDB;
    else
        BlockNum = parseInt(BlockNum);
    if(SetCheckPointOnBlock(BlockNum))
        return {result:1, text:"Set check point on BlockNum=" + BlockNum};
    else
        return {result:0, text:"Error on check point BlockNum=" + BlockNum};
};

function SetCheckPointOnBlock(BlockNum)
{
    if(WALLET.WalletOpen === false)
        return 0;
    var Block = SERVER.ReadBlockHeaderDB(BlockNum);
    if(!Block)
        return 0;
    var SignArr = arr2(Block.Hash, GetArrFromValue(Block.BlockNum));
    var Sign = secp256k1.sign(SHA3BUF(SignArr, Block.BlockNum), WALLET.KeyPair.getPrivateKey('')).signature;
    global.CHECK_POINT = {BlockNum:BlockNum, Hash:Block.Hash, Sign:Sign};
    SERVER.ResetNextPingAllNode();
    return 1;
};
global.SetCheckPointOnBlock = SetCheckPointOnBlock;
var idSetTimeSetCheckPoint;
HTTPCaller.SetAutoCheckPoint = function (Param)
{
    var Ret = CheckCorrectDevKey();
    if(Ret !== true)
        return Ret;
    if(idSetTimeSetCheckPoint)
        clearInterval(idSetTimeSetCheckPoint);
    idSetTimeSetCheckPoint = undefined;
    if(Param.Set)
        idSetTimeSetCheckPoint = setInterval(RunSetCheckPoint, Param.Period * 1000);
    return {result:1, text:"AutoCheck: " + Param.Set + " each " + Param.Period + " sec"};
};
var SumCheckPow = 0;
var CountCheckPow = 0;

function RunSetCheckPoint()
{
    if(!SERVER.BlockNumDB)
        return ;
    if(SERVER.BlockNumDB < 2100000)
        return ;
    var Delta = GetCurrentBlockNumByTime() - SERVER.BlockNumDB;
    if(Delta > 16)
        return ;
    var BlockNum = SERVER.BlockNumDB - global.CheckPointDelta;
    var Block = SERVER.ReadBlockHeaderDB(BlockNum);
    if(Block)
    {
        var Power = GetPowPower(Block.PowHash);
        if(Power < 30)
        {
            ToLog("CANNOT SET CHECK POINT Power=" + Power + "  BlockNum=" + BlockNum);
            return ;
        }
        CountCheckPow++;
        SumCheckPow += Power;
        var AvgPow = SumCheckPow / CountCheckPow;
        if(CountCheckPow > 10)
        {
            if(Power < AvgPow - 2)
            {
                ToLog("**************** CANNOT SET CHECK POINT Power=" + Power + "/" + AvgPow + "  BlockNum=" + BlockNum);
                return ;
            }
        }
        SetCheckPointOnBlock(BlockNum);
        ToLog("SET CHECK POINT Power=" + Power + "/" + AvgPow + "  BlockNum=" + BlockNum);
    }
};
HTTPCaller.SetNewCodeVersion = function (Data)
{
    var Ret = CheckCorrectDevKey();
    if(Ret !== true)
        return Ret;
    var Ret = SERVER.SetNewCodeVersion(Data, WALLET.KeyPair.getPrivateKey(''));
    SERVER.ResetNextPingAllNode();
    return {result:1, text:Ret};
};
HTTPCaller.SetCheckNetConstant = function (Data)
{
    var Ret = CheckCorrectDevKey();
    if(Ret !== true)
        return Ret;
    if(!Data)
    {
        ToLogClient("Data not set");
        return {result:0, text:"Data not set"};
    }
    Data.Num = GetCurrentBlockNumByTime();
    Data.BlockNum = GetCurrentBlockNumByTime() + 10;
    var SignArr = SERVER.GetSignCheckNetConstant(Data);
    Data.Sign = secp256k1.sign(SHA3BUF(SignArr), WALLET.KeyPair.getPrivateKey('')).signature;
    SERVER.CheckNetConstant({NetConstant:Data}, {addrStr:"local"});
    SERVER.ResetNextPingAllNode();
    return {result:1, text:"Set NET_CONSTANT BlockNum=" + Data.BlockNum};
};
HTTPCaller.SetCheckDeltaTime = function (Data)
{
    var Ret = CheckCorrectDevKey();
    if(Ret !== true)
        return Ret;
    if(!Data || !Data.Num)
    {
        ToLogClient("Num not set");
        return {result:0};
    }
    var SignArr = SERVER.GetSignCheckDeltaTime(Data);
    Data.Sign = secp256k1.sign(SHA3BUF(SignArr), WALLET.KeyPair.getPrivateKey('')).signature;
    global.CHECK_DELTA_TIME = Data;
    SERVER.ResetNextPingAllNode();
    return {result:1, text:"Set check time Num=" + Data.Num};
};
var idAutoCorrTime;
HTTPCaller.SetAutoCorrTime = function (bSet)
{
    var Ret = CheckCorrectDevKey();
    if(Ret !== true)
        return Ret;
    if(idAutoCorrTime)
        clearInterval(idAutoCorrTime);
    idAutoCorrTime = undefined;
    if(bSet)
        idAutoCorrTime = setInterval(RunAutoCorrTime, 1000);
    return {result:1, text:"Auto correct: " + bSet};
};
var StartCheckTimeNum = 0;

function RunAutoCorrTime()
{
    if(WALLET.WalletOpen === false)
        return ;
    if(GetCurrentBlockNumByTime() > StartCheckTimeNum && Math.abs(global.DELTA_CURRENT_TIME) >= 120)
    {
        var AutoDelta =  - Math.trunc(global.DELTA_CURRENT_TIME);
        var Data = {Num:GetCurrentBlockNumByTime(), bUse:1, bAddTime:1};
        if(AutoDelta < 0)
        {
            AutoDelta =  - AutoDelta;
            Data.bAddTime = 0;
        }
        Data.DeltaTime = 40;
        Data.StartBlockNum = Data.Num + 5;
        Data.EndBlockNum = Data.StartBlockNum + Math.trunc(AutoDelta / Data.DeltaTime);
        var SignArr = SERVER.GetSignCheckDeltaTime(Data);
        Data.Sign = secp256k1.sign(SHA3BUF(SignArr), WALLET.KeyPair.getPrivateKey('')).signature;
        global.CHECK_DELTA_TIME = Data;
        SERVER.ResetNextPingAllNode();
        StartCheckTimeNum = Data.EndBlockNum + 1;
        ToLog("Auto corr time Num:" + Data.Num + " AutoDelta=" + AutoDelta);
    }
};
HTTPCaller.SaveConstant = function (SetObj)
{
    var WasUpdate = global.USE_AUTO_UPDATE;
    for(var key in SetObj)
    {
        global[key] = SetObj[key];
    }
    SAVE_CONST(true);
    SERVER.DO_CONSTANT();
    WALLET.FindMyAccounts(1);
    if(!WasUpdate && global.USE_AUTO_UPDATE && CODE_VERSION.VersionNum && global.UPDATE_CODE_VERSION_NUM < CODE_VERSION.VersionNum)
    {
        SERVER.UseCode(CODE_VERSION.VersionNum, true);
    }
    if(SetObj.DoRestartNode)
        global.RestartNode();
    else
    {
        if(SetObj.DoMining)
            global.RunStopPOWProcess();
    }
    return {result:1};
};
HTTPCaller.SetHTTPParams = function (SetObj)
{
    global.HTTP_PORT_NUMBER = SetObj.HTTPPort;
    global.HTTP_PORT_PASSWORD = SetObj.HTTPPassword;
    SAVE_CONST(true);
    if(SetObj.DoRestartNode)
        global.RestartNode();
    return {result:1};
};
HTTPCaller.SetNetMode = function (SetObj)
{
    if(!global.NET_WORK_MODE)
        global.NET_WORK_MODE = {};
    for(var key in SetObj)
    {
        global.NET_WORK_MODE[key] = SetObj[key];
    }
    if(NET_WORK_MODE)
    {
        global.START_IP = NET_WORK_MODE.ip;
        global.START_PORT_NUMBER = NET_WORK_MODE.port;
    }
    SAVE_CONST(true);
    if(SetObj.DoRestartNode)
        global.RestartNode();
    return {result:1};
};
HTTPCaller.GetAccountKey = function (Num)
{
    var Result = {};
    Result.result = 0;
    var KeyPair = WALLET.GetAccountKey(Num);
    if(KeyPair)
    {
        Result.result = 1;
        Result.PubKeyStr = GetHexFromArr(KeyPair.getPublicKey('', 'compressed'));
    }
    return Result;
};
HTTPCaller.GetHotArray = function (Param)
{
    var ArrTree = SERVER.GetTransferTree();
    if(!ArrTree)
        return {result:0};
    for(var Level = 0; Level < ArrTree.length; Level++)
    {
        var arr = ArrTree[Level];
        if(arr)
            for(var n = 0; n < arr.length; n++)
            {
                arr[n].GetTiming = 0;
            }
    }
    var BlockCounts = 0;
    if(Param && Param.CountBlock)
        for(var i = SERVER.CurrentBlockNum - Param.CountBlock; i <= SERVER.CurrentBlockNum - Param.CountBlock; i++)
        {
            var Block = SERVER.GetBlock(i);
            if(!Block || !Block.Active || !Block.LevelsTransfer)
            {
                continue;
            }
            BlockCounts++;
            for(var n = 0; n < Block.LevelsTransfer.length; n++)
            {
                var Transfer = Block.LevelsTransfer[n];
                for(var Addr in Transfer.TransferNodes)
                {
                    var Item = Transfer.TransferNodes[Addr];
                    Item.Node.GetTiming += Item.GetTiming;
                }
            }
        }
    for(var Level = 0; Level < ArrTree.length; Level++)
    {
        var arr = ArrTree[Level];
        if(!arr)
            continue;
        arr.sort(SortNodeHot);
        for(var n = 0; n < arr.length; n++)
        {
            arr[n] = GetCopyNode(arr[n], BlockCounts);
        }
    }
    
function SortNodeHot(a,b)
    {
        if(b.Hot !== a.Hot)
            return b.Hot - a.Hot;
        if(b.BlockProcessCount !== a.BlockProcessCount)
            return b.BlockProcessCount - a.BlockProcessCount;
        if(a.DeltaTime !== b.DeltaTime)
            return a.DeltaTime - b.DeltaTime;
        return a.id - b.id;
    };
    return {result:1, ArrTree:ArrTree};
};

function GetCopyNode(Node,BlockCounts)
{
    if(!Node)
        return ;
    if(Node.Socket && Node.Socket.Info)
    {
        Node.Info += Node.Socket.Info + "\n";
        Node.Socket.Info = "";
    }
    if(!Node.PrevInfo)
        Node.PrevInfo = "";
    var GetTiming = 0;
    if(BlockCounts !== 0)
        GetTiming = Math.trunc(Node.GetTiming / BlockCounts) / 1000;
    var Item = {VersionNum:Node.VersionNum, LevelsBit:Node.LevelsBit, NoSendTx:Node.NoSendTx, GetNoSendTx:Node.GetNoSendTx, DirectMAccount:Node.DirectMAccount,
        id:Node.id, ip:Node.ip, portweb:Node.portweb, port:Node.port, TransferCount:Node.TransferCount, GetTiming:GetTiming, ErrCountAll:Node.ErrCountAll,
        LevelCount:Node.LevelCount, LevelEnum:Node.LevelEnum, TimeTransfer:GetStrOnlyTimeUTC(new Date(Node.LastTimeTransfer)), BlockProcessCount:Node.BlockProcessCount,
        DeltaTime:Node.DeltaTime, DeltaTimeM:Node.DeltaTimeM, DeltaGlobTime:Node.DeltaGlobTime, PingNumber:Node.PingNumber, NextConnectDelta:Node.NextConnectDelta,
        NextGetNodesDelta:Node.NextGetNodesDelta, NextHotDelta:Node.NextHotDelta, Name:Node.Name, addrStr:Node.addrStr, CanHot:Node.CanHot,
        Active:Node.Active, Hot:Node.Hot, Info:Node.PrevInfo + Node.Info, InConnectArr:Node.WasAddToConnect, Level:Node.Level, TransferBlockNum:Node.TransferBlockNum,
        TransferSize:Node.TransferSize, TransferBlockNumFix:Node.TransferBlockNumFix, CurBlockNum:Node.CurBlockNum, };
    return Item;
};
HTTPCaller.GetBlockchainStat = function (Param)
{
    var Result = SERVER.GetStatBlockchainPeriod(Param);
    Result.result = 1;
    Result.sessionid = sessionid;
    return Result;
};
HTTPCaller.GetAllCounters = function (Params,response)
{
    let Result = GET_STATS();
    Result.result = 1;
    Result.sessionid = sessionid;
    Result.STAT_MODE = global.STAT_MODE;
    if(!global.TX_PROCESS || !global.TX_PROCESS.RunRPC)
        return Result;
    global.TX_PROCESS.RunRPC("GET_STATS", "", function (Err,Params)
    {
        Result.result = !Err;
        if(Result.result)
        {
            AddStatData(Params, Result, "TX");
        }
        if(global.WEB_PROCESS && global.WEB_PROCESS.RunRPC)
        {
            global.WEB_PROCESS.RunRPC("GET_STATS", "", function (Err,Params)
            {
                Result.result = !Err;
                if(Result.result)
                {
                    AddStatData(Params, Result, "WEB");
                }
                response.end(JSON.stringify(Result));
            });
        }
        else
        {
            response.end(JSON.stringify(Result));
        }
    });
    return null;
};

function AddStatData(Params,Result,Prefix)
{
    for(var name in Params.stats)
    {
        for(var key in Params.stats[name])
        {
            var Item = Params.stats[name][key];
            Result.stats[name][key + "-" + Prefix] = Item;
        }
    }
};
HTTPCaller.SetStatMode = function (flag)
{
    if(flag)
        StartCommonStat();
    global.STAT_MODE = flag;
    SAVE_CONST(true);
    global.TX_PROCESS.RunRPC("LOAD_CONST");
    return {result:1, sessionid:sessionid, STAT_MODE:global.STAT_MODE};
};
HTTPCaller.ClearStat = function ()
{
    global.ClearCommonStat();
    if(global.TX_PROCESS && global.TX_PROCESS.RunRPC)
    {
        global.TX_PROCESS.RunRPC("ClearCommonStat", "", function (Err,Params)
        {
        });
    }
    if(global.WEB_PROCESS && global.WEB_PROCESS.RunRPC)
    {
        global.WEB_PROCESS.RunRPC("ClearCommonStat", "", function (Err,Params)
        {
        });
    }
    return {result:1, sessionid:sessionid, STAT_MODE:global.STAT_MODE};
};
HTTPCaller.RewriteAllTransactions = function (Param)
{
    RewriteAllTransactions();
    return {result:1, sessionid:sessionid};
};
HTTPCaller.RewriteTransactions = function (Param)
{
    var Ret = SERVER.ReWriteDAppTransactions(Param.BlockCount);
    return {result:Ret, sessionid:sessionid};
};
HTTPCaller.TruncateBlockChain = function (Param)
{
    var StartNum = SERVER.BlockNumDB - Param.BlockCount;
    var MinBlock = DApps.Accounts.GetMinBlockAct();
    if(MinBlock > StartNum)
    {
        ToLog("Cant Truncate BlockChain. Very long length. Max length=" + (SERVER.BlockNumDB - MinBlock), 0);
        return {result:0, sessionid:sessionid};
    }
    SERVER.TruncateBlockDB(StartNum);
    return {result:1, sessionid:sessionid};
};
HTTPCaller.ClearDataBase = function (Param)
{
    BlockTree.Clear();
    SERVER.ClearDataBase();
    return {result:1, sessionid:sessionid};
};
HTTPCaller.CleanChain = function (Param)
{
    if(global.CleanChain)
    {
        var StartNum = SERVER.BlockNumDB - Param.BlockCount;
        global.CleanChain(StartNum);
        return {result:1, sessionid:sessionid};
    }
    return {result:0, sessionid:sessionid};
};
HTTPCaller.GetArrStats = function (Keys,response)
{
    var arr = GET_STATDIAGRAMS(Keys);
    let Result = {result:1, sessionid:sessionid, arr:arr, STAT_MODE:global.STAT_MODE};
    if(!global.TX_PROCESS || !global.TX_PROCESS.RunRPC)
        return Result;
    var Keys2 = [];
    for(var i = 0; i < Keys.length; i++)
    {
        var Str = Keys[i];
        if(Str.substr(Str.length - 3) == "-TX")
            Keys2.push(Str.substr(0, Str.length - 3));
    }
    global.TX_PROCESS.RunRPC("GET_STATDIAGRAMS", Keys2, function (Err,Arr)
    {
        Result.result = !Err;
        if(Result.result)
        {
            for(var i = 0; i < Arr.length; i++)
            {
                var Item = Arr[i];
                Item.name = Item.name + "-TX";
                Result.arr.push(Item);
            }
        }
        var Str = JSON.stringify(Result);
        response.end(Str);
    });
    return null;
};
HTTPCaller.GetBlockChain = function (type)
{
    if(!global.SERVER || !SERVER.LoadedChainList)
    {
        return {result:0};
    }
    var MainChains = {};
    for(var i = 0; i < SERVER.LoadedChainList.length; i++)
    {
        var chain = SERVER.LoadedChainList[i];
        if(chain && !chain.Deleted)
            MainChains[chain.id] = true;
    }
    var arrBlocks = [];
    var arrLoadedChainList = [];
    var arrLoadedBlocks = [];
    for(var key in SERVER.BlockChain)
    {
        var Block = SERVER.BlockChain[key];
        if(Block)
        {
            arrBlocks.push(CopyBlockDraw(Block, MainChains));
        }
    }
    AddChainList(arrLoadedChainList, SERVER.LoadedChainList, true);
    AddMapList(arrLoadedBlocks, type, SERVER.MapMapLoaded, MainChains);
    var ArrLoadedChainList = global.HistoryBlockBuf.LoadValue("LoadedChainList", 1);
    if(ArrLoadedChainList)
        for(var List of ArrLoadedChainList)
        {
            AddChainList(arrLoadedChainList, List);
        }
    var ArrMapMapLoaded = global.HistoryBlockBuf.LoadValue("MapMapLoaded", 1);
    if(ArrMapMapLoaded)
        for(var List of ArrMapMapLoaded)
        {
            AddMapList(arrLoadedBlocks, type, List);
        }
    var obj = {LastCurrentBlockNum:SERVER.GetLastCorrectBlockNum(), CurrentBlockNum:SERVER.CurrentBlockNum, LoadedChainList:arrLoadedChainList,
        LoadedBlocks:arrLoadedBlocks, BlockChain:arrBlocks, port:SERVER.port, DELTA_CURRENT_TIME:DELTA_CURRENT_TIME, memoryUsage:process.memoryUsage(),
        IsDevelopAccount:IsDeveloperAccount(WALLET.PubKeyArr), LoadedChainCount:SERVER.LoadedChainList.length, StartLoadBlockTime:SERVER.StartLoadBlockTime,
        sessionid:sessionid, result:1};
    var obj2 = HTTPCaller.GetHotArray();
    obj.ArrTree = obj2.ArrTree;
    arrBlocks = [];
    arrLoadedChainList = [];
    arrLoadedBlocks = [];
    return obj;
};
HTTPCaller.GetHistoryTransactions = function (Params)
{
    if(typeof Params === "object" && Params.AccountID)
    {
        var Account = DApps.Accounts.ReadState(Params.AccountID);
        if(!Account)
            return {result:0};
        if(!Params.Count)
            Params.Count = 100;
        var arr = DApps.Accounts.GetHistory(Params.AccountID, Params.Count, Params.NextPos);
        if(Params.GetDescription)
        {
            for(var i = 0; i < arr.length; i++)
            {
                var Item = arr[i];
                var Block = SERVER.ReadBlockDB(Item.BlockNum);
                if(!Block || (!Block.arrContent))
                    continue;
                var Body = Block.arrContent[Item.TrNum];
                if(!Body)
                    continue;
                var TR = DApps.Accounts.GetObjectTransaction(Body);
                if(TR)
                    Item.Description = TR.Description;
            }
        }
        var Result = {Value:{SumCOIN:Account.Value.SumCOIN, SumCENT:Account.Value.SumCENT}, Name:Account.Name, Currency:Account.Currency,
            MaxBlockNum:GetCurrentBlockNumByTime(), FIRST_TIME_BLOCK:FIRST_TIME_BLOCK, result:arr.length > 0 ? 1 : 0, History:arr};
        return Result;
    }
    return {result:0};
};

function GetCopyBlock(Block)
{
    var Result = {BlockNum:Block.BlockNum, bSave:Block.bSave, TreeHash:GetHexFromAddres(Block.TreeHash), AddrHash:GetHexFromAddres(Block.AddrHash),
        PrevHash:GetHexFromAddres(Block.PrevHash), SumHash:GetHexFromAddres(Block.SumHash), SumPow:Block.SumPow, TrDataPos:Block.TrDataPos,
        TrDataLen:Block.TrDataLen, SeqHash:GetHexFromAddres(Block.SeqHash), Hash:GetHexFromAddres(Block.Hash), Power:GetPowPower(Block.PowHash),
        TrCount:Block.TrCount, arrContent:Block.arrContent, };
    return Result;
};
var AddrLength = 16;

function GetHexFromAddresShort(Hash)
{
    return GetHexFromAddres(Hash).substr(0, AddrLength);
};

function GetHexFromStrShort(Str)
{
    if(Str === undefined)
        return Str;
    else
        return Str.substr(0, AddrLength);
};
var glid = 0;

function GetGUID(Block)
{
    if(!Block)
        return "------";
    if(!Block.guid)
    {
        glid++;
        Block.guid = glid;
    }
    return Block.guid;
};

function CopyBlockDraw(Block,MainChains)
{
    var MinerID = 0;
    var MinerName = "";
    if(Block.AddrHash)
    {
        var Num = ReadUintFromArr(Block.AddrHash, 0);
        MinerID = Num;
        var Item = DApps.Accounts.ReadState(Num);
        if(Item && Item.Name)
            MinerName = Item.Name.substr(0, 8);
    }
    var CheckPoint = 0;
    if(Block.BlockNum === CHECK_POINT.BlockNum)
        CheckPoint = 1;
    var Mining;
    if(SERVER.MiningBlock === Block)
        Mining = 1;
    else
        Mining = 0;
    GetGUID(Block);
    var Item = {guid:Block.guid, Active:Block.Active, bSave:Block.bSave, Prepared:Block.Prepared, BlockNum:Block.BlockNum, Hash:GetHexFromAddresShort(Block.Hash),
        SumHash:GetHexFromAddresShort(Block.SumHash), SeqHash:GetHexFromAddresShort(Block.SeqHash), TreeHash:GetHexFromAddresShort(Block.TreeHash),
        AddrHash:GetHexFromAddresShort(Block.AddrHash), MinerID:MinerID, MinerName:MinerName, Comment1:Block.Comment1, Comment2:Block.Comment2,
        SumPow:Block.SumPow, Info:Block.Info, TreeLoaded:Block.TreeEq, AddToLoad:Block.AddToLoad, LoadDB:Block.LoadDB, FindBlockDB:Block.FindBlockDB,
        TrCount:Block.TrCount, ArrLength:0, TrDataLen:Block.TrDataLen, Power:GetPowPower(Block.PowHash), CheckPoint:CheckPoint, Mining:Mining,
        TransferSize:Block.TransferSize, HasErr:Block.HasErr, };
    if(Block.chain)
        Item.chainid = Block.chain.id;
    if(Block.LoadDB !== undefined)
        Item.bSave = Block.LoadDB;
    if(Block.arrContent)
        Item.TrCount = Block.arrContent.length;
    Item.BlockDown = GetGUID(Block.BlockDown);
    if(MainChains && Item.chainid)
    {
        Item.Main = MainChains[Item.chainid];
    }
    return Item;
};

function CopyChainDraw(Chain,bWasRecursive,bMain)
{
    if(!Chain)
        return Chain;
    GetGUID(Chain);
    var Item = {guid:Chain.guid, id:Chain.id, chainid:Chain.id, bSave:Chain.LoadDB, FindBlockDB:Chain.FindBlockDB, GetFindDB:Chain.GetFindDB(),
        BlockNum:Chain.BlockNumStart, Hash:GetHexFromAddresShort(Chain.HashStart), Comment1:Chain.Comment1, Comment2:Chain.Comment2,
        StopSend:Chain.StopSend, SumPow:0, Info:Chain.Info, IsSum:Chain.IsSum, Main:bMain, };
    if(Chain.IsSumStart)
    {
        Item.SumHash = Item.Hash;
        Item.Hash = "-------";
    }
    if(Chain.RootChain)
    {
        var rootChain = Chain.GetRootChain();
        if(rootChain)
        {
            Item.rootid = rootChain.id;
            if(!bWasRecursive)
                Item.root = CopyChainDraw(rootChain, true);
        }
    }
    else
        Item.rootid = "";
    if(Chain.BlockHead)
    {
        Item.HashMaxStr = GetGUID(Chain.BlockHead);
        Item.BlockNumMax = Chain.BlockHead.BlockNum;
    }
    else
    {
        Item.HashMaxStr = "------";
    }
    return Item;
};

function AddChainList(arrLoadedChainList,LoadedChainList,bMain)
{
    for(var chain of LoadedChainList)
    {
        if(chain)
        {
            arrLoadedChainList.push(CopyChainDraw(chain, false, bMain));
        }
    }
};

function AddMapList(arrLoadedBlocks,type,MapMapLoaded,MainChains)
{
    for(var key in MapMapLoaded)
    {
        var map = MapMapLoaded[key];
        if(map)
        {
            for(var key in map)
            {
                var Block = map[key];
                if(key.substr(1, 1) === ":")
                    continue;
                if(!Block.Send || type === "reload")
                {
                    arrLoadedBlocks.push(CopyBlockDraw(Block, MainChains));
                    Block.Send = true;
                }
            }
        }
    }
};
var MapFileHTML5 = {};

function SendWebFile(response,name,StrCookie,bParsing)
{
    var type = name.substr(name.length - 4, 4);
    var index1 = type.indexOf(".");
    type = type.substr(index1 + 1);
    var Path;
    if(name.substr(0, 2) !== "./")
        Path = "./" + name;
    else
        Path = name;
    if(!fs.existsSync(Path))
    {
        if(type === "ico")
        {
            response.writeHead(404, {'Content-Type':'text/html'});
            response.end();
            return ;
        }
        var data = "Not found: " + name;
        response.end(data);
        return ;
    }
    var StrContentType = ContenTypeMap[type];
    if(!StrContentType)
        StrContentType = DefaultContentType;
    if(StrContentType === "text/html")
    {
        var Headers = {'Content-Type':'text/html', "X-Frame-Options":"sameorigin"};
        if(StrCookie)
            Headers['Set-Cookie'] = StrCookie;
        response.writeHead(200, Headers);
    }
    else
    {
        if(StrContentType === "application/font-woff")
        {
            response.writeHead(200, {'Content-Type':StrContentType, 'Access-Control-Allow-Origin':"*"});
        }
        else
            response.writeHead(200, {'Content-Type':StrContentType});
    }
    if(bParsing && StrContentType === "text/html")
    {
        var data = GetFileHTMLWithParsing(Path);
        response.end(data);
        return ;
    }
    else
        if("image/jpeg,image/vnd.microsoft.icon,image/svg+xml,image/png,application/javascript,text/css,text/html".indexOf(StrContentType) >  - 1)
        {
            var data = GetFileSimpleBin(Path);
            response.end(data);
            return ;
        }
    const stream = fs.createReadStream(Path);
    setTimeout(function ()
    {
        stream.close();
        stream.push(null);
        stream.read(0);
    }, 100000);
    stream.pipe(response);
};

function GetFileHTMLWithParsing(Path)
{
    var data = global.SendHTMLMap[Path];
    if(!data)
    {
        global.SendHTMLMap[Path] = "-recursion-";
        data = String(fs.readFileSync(Path));
        data = ParseTag(data, "File", 0);
        data = ParseTag(data, "Edit", 1);
        global.SendHTMLMap[Path] = data;
    }
    return data;
};
var glEditNum = 0;

function ParseTag(Str,TagName,bEdit)
{
    var bWasInject = 0;
    var data = "";
    var index = 0;
    while(index >= 0)
    {
        index = Str.indexOf("{{" + TagName + "=", index);
        if(index >= 0)
        {
            var index2 = Str.indexOf("}}", index + 3 + TagName.length);
            if(index2 < 0)
            {
                ToLog("Error teg " + TagName + " in " + Path);
                break;
            }
            var Delta = index2 - index;
            if(Delta > 210)
            {
                ToLog("Error length (more 200) teg File in " + Path);
                break;
            }
            var Path2 = Str.substring(index + 3 + TagName.length, index + Delta);
            data += Str.substring(0, index);
            if(bEdit)
            {
                if(!bWasInject)
                {
                    data = data + GetFileSimple("./SITE/JS/web-edit.html");
                    bWasInject = 1;
                }
                glEditNum++;
                data += "<DIV class='' id='idEdit" + glEditNum + "'>";
                data += GetFileHTMLFromMarkdown(Path2);
                data += "</DIV>";
                data += "<script>AddNewEditTag('idEdit" + glEditNum + "','" + Path2 + "');</script>";
            }
            else
            {
                data += GetFileHTMLWithParsing(Path2);
            }
            Str = Str.substring(index2 + 2);
            index = 0;
        }
    }
    data += Str;
    return data;
};
var MarkLib;

function GetFileHTMLFromMarkdown(Path)
{
    var data = global.SendHTMLMap[Path];
    if(!data)
    {
        if(MarkLib === undefined)
            MarkLib = require("../HTML/JS/marked.js");
        var Str = "";
        if(fs.existsSync(Path))
            Str = String(fs.readFileSync(Path));
        data = MarkLib(Str);
        global.SendHTMLMap[Path] = data;
    }
    return data;
};

function GetFileSimple(Path)
{
    var Key = "GetFileSimple-" + Path;
    var data = global.SendHTMLMap[Key];
    if(!data)
    {
        data = String(fs.readFileSync(Path));
        global.SendHTMLMap[Key] = data;
    }
    return data;
};

function GetFileSimpleBin(Path)
{
    var Key = "GetFileSimpleBin-" + Path;
    var data = global.SendHTMLMap[Key];
    if(!data)
    {
        data = (fs.readFileSync(Path));
        global.SendHTMLMap[Key] = data;
    }
    return data;
};

function SaveFileSimple(Path,Str)
{
    global.SendHTMLMap = {};
    var Key = "GetFileSimple-" + Path;
    global.SendHTMLMap[Key] = Str;
    SaveToFile(Path, Str);
};
global.SendHTMLMap = {};
global.SendWebFile = SendWebFile;
global.GetFileHTMLWithParsing = GetFileHTMLWithParsing;
global.GetFileHTMLFromMarkdown = GetFileHTMLFromMarkdown;
global.GetFileSimple = GetFileSimple;
global.SaveFileSimple = SaveFileSimple;

function ReloaSenddBufer()
{
    global.SendHTMLMap = {};
};
setInterval(ReloaSenddBufer, 60 * 1000);
if(global.DEV_MODE)
    setInterval(ReloaSenddBufer, 1 * 1000);

function GetStrTime(now)
{
    if(!now)
        now = GetCurrentTime(0);
    var Str = "" + now.getHours().toStringZ(2);
    Str = Str + ":" + now.getMinutes().toStringZ(2);
    Str = Str + ":" + now.getSeconds().toStringZ(2);
    return Str;
};

function OnGetData(arg)
{
    var response = {end:function ()
        {
        }, writeHead:function ()
        {
        }, };
    var Path = arg.path;
    var obj = arg.obj;
    if(Path.substr(0, 1) === "/")
        Path = Path.substr(1);
    var params = Path.split('/', 5);
    var Ret;
    var F = HTTPCaller[params[0]];
    if(F)
    {
        if(obj)
            Ret = F(obj);
        else
            Ret = F(params[1], params[2], params[3]);
    }
    else
    {
        Ret = {result:0};
    }
    return Ret;
};

function parseCookies(rc)
{
    var list = {};
    rc && rc.split(';').forEach(function (cookie)
    {
        var parts = cookie.split('=');
        list[parts.shift().trim()] = decodeURI(parts.join('='));
    });
    return list;
};
global.SetSafeResponce = SetSafeResponce;

function SetSafeResponce(response)
{
    if(!response.Safe)
    {
        response.Safe = 1;
        response._end = response.end;
        response._writeHead = response.writeHead;
        response.end = function ()
        {
            try
            {
                if(global.STAT_MODE === 2 && arguments && arguments[0] && arguments[0].length)
                {
                    ADD_TO_STAT("HTTP_SEND", arguments[0].length);
                    if(response.DetailStatName)
                        ADD_TO_STAT("HTTP_SEND" + response.DetailStatName, arguments[0].length);
                }
                response._end.apply(response, arguments);
            }
            catch(e)
            {
                ToError("H##1");
                ToError(e);
            }
        };
        response.writeHead = function ()
        {
            try
            {
                response._writeHead.apply(response, arguments);
            }
            catch(e)
            {
                ToError("H##2");
                ToError(e);
            }
        };
    }
};
if(global.HTTP_PORT_NUMBER)
{
    var ClientTokenMap = {};
    var ClientIPMap = {};
    setInterval(function ()
    {
        ClientTokenMap = {};
    }, 24 * 3600 * 1000);
    var port = global.HTTP_PORT_NUMBER;
    var HTTPServer = http.createServer(function (request,response)
    {
        if(!request.headers)
            return ;
        if(!request.socket || !request.socket.remoteAddress)
            return ;
        var remoteAddress = request.socket.remoteAddress.replace(/^.*:/, '');
        if(remoteAddress === "1")
            remoteAddress = "127.0.0.1";
        var CheckPassword;
        if(!global.HTTP_PORT_PASSWORD && remoteAddress.indexOf("127.0.0.1") < 0)
            return ;
        if(global.HTTP_IP_CONNECT && remoteAddress.indexOf("127.0.0.1") < 0 && global.HTTP_IP_CONNECT.indexOf(remoteAddress) < 0)
            return ;
        CheckPassword = 1;
        SetSafeResponce(response);
        if(!global.SERVER)
        {
            response.writeHead(404, {'Content-Type':'text/html'});
            response.end("");
            return ;
        }
        var fromURL = url.parse(request.url);
        var Path = querystring.unescape(fromURL.path);
        if(!ClientIPMap[remoteAddress])
        {
            ClientIPMap[remoteAddress] = 1;
            ToLog("CONNECT TO HTTP ACCESS FROM: " + remoteAddress, 0);
            ToLog("Path: " + Path, 0);
        }
        if(CheckPassword && global.HTTP_PORT_PASSWORD)
        {
            var StrPort = "";
            if(global.HTTP_PORT_NUMBER !== 80)
                StrPort = global.HTTP_PORT_NUMBER;
            var cookies = parseCookies(request.headers.cookie);
            var cookies_token = cookies["token" + StrPort];
            var cookies_hash = cookies["hash" + StrPort];
            if(cookies_token && cookies_hash && ClientTokenMap[cookies_token] === 0)
            {
                if(cookies_hash.substr(0, 4) !== "0000")
                {
                    SendWebFile(response, "./HTML/password.html", "token" + StrPort + "=" + cookies_token + ";path=/");
                    return ;
                }
                var nonce = 0;
                var index = cookies_hash.indexOf("-");
                if(index > 0)
                {
                    nonce = parseInt(cookies_hash.substr(index + 1));
                    if(!nonce)
                        nonce = 0;
                }
                var hash = ClientHex(cookies_token + "-" + global.HTTP_PORT_PASSWORD, nonce);
                if(hash === cookies_hash)
                {
                    ClientTokenMap[cookies_token] = 1;
                }
                else
                {
                    SendWebFile(response, "./HTML/password.html", "token" + StrPort + "=" + cookies_token + ";path=/");
                    return ;
                }
            }
            if(!cookies_token || !ClientTokenMap[cookies_token])
            {
                var StrToken = GetHexFromArr(crypto.randomBytes(16));
                ClientTokenMap[StrToken] = 0;
                SendWebFile(response, "./HTML/password.html", "token" + StrPort + "=" + StrToken + ";path=/");
                return ;
            }
        }
        var params = Path.split('/', 6);
        params.splice(0, 1);
        var Type = request.method;
        if(Type === "POST")
        {
            let Response = response;
            let Params = params;
            let postData = "";
            request.addListener("data", function (postDataChunk)
            {
                if(postData.length < 70000 && postDataChunk.length < 70000)
                    postData += postDataChunk;
            });
            request.addListener("end", function ()
            {
                var Data;
                try
                {
                    Data = JSON.parse(postData);
                }
                catch(e)
                {
                    ToError("--------Error data parsing : " + Params[0] + " " + postData.substr(0, 200));
                    Response.writeHead(405, {'Content-Type':'text/html'});
                    Response.end("Error data parsing");
                }
                if(Params[0] === "HTML")
                    DoCommand(response, Type, Path, [Params[1], Data], remoteAddress);
                else
                    DoCommand(response, Type, Path, [Params[0], Data], remoteAddress);
            });
        }
        else
        {
            DoCommand(response, Type, Path, params, remoteAddress);
        }
    }).listen(port, LISTEN_IP, function ()
    {
        global.HTTP_SERVER_START_OK = 1;
        ToLog("Run HTTP-server on " + LISTEN_IP + ":" + port);
    });
    HTTPServer.on('error', function (err)
    {
        ToError("H##3");
        ToError(err);
    });
}
if(global.ELECTRON)
{
    const ipcMain = require('electron').ipcMain;
    ipcMain.on('GetData', function (event,arg)
    {
        event.returnValue = OnGetData(arg);
    });
}
exports.SendData = OnGetData;

function RunConsole(StrRun)
{
    var Str = fs.readFileSync("./EXPERIMENTAL/_run-console.js", {encoding:"utf8"});
    if(StrRun)
        Str += "\n" + StrRun;
    try
    {
        var ret = eval(Str);
    }
    catch(e)
    {
        ret = e.message + "\n" + e.stack;
    }
    return ret;
};
var WebWalletUser = {};

function GetUserContext(Params)
{
    if(typeof Params.Key !== "string")
        Params.Key = "" + Params.Key;
    var StrKey = Params.Key + "-" + Params.Session;
    var Context = WebWalletUser[StrKey];
    if(!Context)
    {
        Context = {NumDappInfo:0, PrevDappInfo:"", NumAccountList:0, PrevAccountList:"", LastTime:0, FromEventNum:0};
        Context.Session = Params.Session;
        Context.Key = StrKey;
        WebWalletUser[StrKey] = Context;
    }
    return Context;
};
global.GetUserContext = GetUserContext;
global.EventNum = 0;
global.EventMap = {};

function AddDappEventToGlobalMap(Data)
{
    global.EventNum++;
    Data.EventNum = global.EventNum;
    Data.EventDate = Date.now();
    var Arr = global.EventMap[Data.Smart];
    if(!Arr)
    {
        Arr = [];
        global.EventMap[Data.Smart] = Arr;
    }
    if(Arr.length < 1000)
    {
        Arr.push(Data);
    }
};
global.AddDappEventToGlobalMap = AddDappEventToGlobalMap;

function DeleteOldEvents(SmartNum)
{
    var CurDate = Date.now();
    var Arr = global.EventMap[SmartNum];
    while(Arr && Arr.length)
    {
        var Event = Arr[0];
        if(!Event || CurDate - Event.EventDate < 5000)
        {
            break;
        }
        Arr.splice(0, 1);
    }
};

function GetEventArray(SmartNum,Context)
{
    var Arr = global.EventMap[SmartNum];
    if(!Arr || Arr.length === 0)
    {
        return [];
    }
    var FromEventNum = Context.FromEventNum;
    var ArrRet = [];
    for(var i = 0; i < Arr.length; i++)
    {
        var Event = Arr[i];
        if(Event.EventNum >= FromEventNum)
            ArrRet.push(Event);
    }
    if(ArrRet.length)
    {
        Context.FromEventNum = ArrRet[ArrRet.length - 1].EventNum + 1;
    }
    return ArrRet;
};
HTTPCaller.GetHashRate = function (ArrParams)
{
    var AllReadCount = 0;
    var CurBlockNum = GetCurrentBlockNumByTime();
    var ResArr = [];
    for(var i = 0; i < ArrParams.length; i++)
    {
        var Item = ArrParams[i];
        if(!Item)
        {
            ResArr[i] = undefined;
            continue;
        }
        if(Item.BlockNum1 < 0)
            Item.BlockNum1 = 0;
        if(Item.BlockNum2 > CurBlockNum)
            Item.BlockNum2 = CurBlockNum;
        var Delta = Item.BlockNum2 - Item.BlockNum1;
        var Count = Delta;
        if(Count > 20)
            Count = 20;
        else
            if(Count <= 0)
                Count = 1;
        var StepDelta = Math.floor(Delta / Count);
        if(StepDelta < 1)
            StepDelta = 1;
        var CountAvg = 3;
        var StepDeltaAvg = Math.floor(StepDelta / CountAvg);
        if(StepDeltaAvg < 1)
            StepDeltaAvg = 1;
        var ItervalArr = [];
        for(var Num = Item.BlockNum1; Num < Item.BlockNum2; Num += StepDelta)
        {
            var Power;
            var Item2 = BlockTree.LoadValue(Num, 1);
            if(Item2 && i !== ArrParams.length - 1)
            {
                Power = Item2.Power;
            }
            else
            {
                var Sum = 0;
                var CountSum = 0;
                for(var d = 0; d < CountAvg; d++)
                {
                    var Block = SERVER.ReadBlockHeaderFromMapDB(Num + d * StepDeltaAvg);
                    if(Block)
                    {
                        if(!Block.FromMap)
                            AllReadCount++;
                        CountSum++;
                        Sum += GetPowPower(Block.PowHash);
                    }
                }
                if(!CountSum)
                    CountSum = 1;
                Power = Math.floor(Sum / CountSum);
                if(Power)
                    BlockTree.SaveValue(Num, {BlockNum:Num, Power:Power});
            }
            ItervalArr.push(Power);
        }
        ResArr[i] = ItervalArr;
    }
    return {result:1, ItervalArr:ResArr};
};