/*
 * @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";
import './crypto-library'
import './log'
import { secp256k1 } from '../core/library'
import * as http from 'http'
import * as url from 'url'
import * as fs from 'fs'
import * as querystring from 'querystring'
import * as crypto from 'crypto';
import { STreeBuffer } from './base';
import { TYPE_TRANSACTION } from '../constant/account';

var BlockTree = new STreeBuffer(300 * 1000, global.CompareItemHashSimple, "number");
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["png"] = "image/png";
ContenTypeMap["gif"] = "image/gif";
ContenTypeMap["jpg"] = "image/jpeg";
ContenTypeMap["html"] = "text/html";
ContenTypeMap["txt"] = "text/plain";
ContenTypeMap["csv"] = "text/csv";
ContenTypeMap["svg"] = "image/svg+xml";
ContenTypeMap[""] = "application/octet-stream";
ContenTypeMap["zip"] = "application/zip";
ContenTypeMap["pdf"] = "application/pdf";
ContenTypeMap["exe"] = "application/octet-stream";
ContenTypeMap["msi"] = "application/octet-stream";
ContenTypeMap["woff"] = "application/font-woff";
ContenTypeMap[".js"] = "application/javascript";
ContenTypeMap["html"] = "text/html";
ContenTypeMap["psd"] = "application/octet-stream";
global.HTTPCaller = {};

function DoCommand(response, Type, Path, params, remoteAddress) {
    var F = global.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) {
            global.ToLog("ERR PATH:" + Path);
            global.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)
                    global.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 <= global.DApps.Smart.GetMaxNum()) {
        var Data = global.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 <= global.DApps.Smart.GetMaxNum()) {
        var Data = global.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 <= global.DApps.Smart.GetMaxNum()) {
        var Data = global.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();
};
global.HTTPCaller.DappSmartHTMLFile = function(Params) {
    var Data = global.DApps.Smart.ReadSmart(global.ParseNum(Params.Smart));
    if (Data) {
        if (global.DEV_MODE && Params.DebugPath) {
            global.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 <= global.SERVER.GetMaxNumBlockDB() && TrNum <= global.MAX_TRANSACTION_COUNT) {
        var Block = global.SERVER.ReadBlockDB(BlockNum);
        if (Block && Block.arrContent) {
            SendToResponceFile(response, Block, TrNum);
            return;
        } else {
            if (!Block || !Block.TrDataPos) {
                global.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] === TYPE_TRANSACTION.TYPE_TRANSACTION_FILE) {
        var TR = global.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();
};
global.HTTPCaller.DappBlockFile = function(Params, response) {
    Params.BlockNum = global.ParseNum(Params.BlockNum);
    Params.TrNum = global.ParseNum(Params.TrNum);
    if (!Params.TrNum)
        Params.TrNum = 0;
    if (Params.BlockNum && Params.BlockNum <= global.SERVER.GetMaxNumBlockDB() && Params.TrNum <= global.MAX_TRANSACTION_COUNT) {
        var Block = global.SERVER.ReadBlockDB(Params.BlockNum);
        if (Block && Block.arrContent) {
            SendToResponceDappFile(response, Block, Params.TrNum);
            return null;
        } else {
            if (!Block || !Block.TrDataPos) {
                global.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: any = { result: 0 };
    var Body = Block.arrContent[TrNum];
    if (Body) {
        var Type = Body[0];
        if (Type === TYPE_TRANSACTION.TYPE_TRANSACTION_FILE) {
            var TR = global.DApps.File.GetObjectTransaction(Body);
            Result = { result: 1, Type: Type, ContentType: TR.ContentType, Name: TR.Name, Body: TR.Data.toString('utf8') };
        } else {
            var App = global.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;
global.HTTPCaller.DappStaticCall = function(Params, response) {
    global.DApps.Accounts.BeginBlock();
    global.DApps.Accounts.BeginTransaction();
    global.TickCounter = 100000;
    var Account = global.DApps.Accounts.ReadStateTR(global.ParseNum(Params.Account));
    if (!Account) {
        return { result: 0, RetValue: "Error account Num: " + Params.Account };
    }
    if (!glBlock0)
        glBlock0 = global.SERVER.ReadBlockHeaderDB(0);
    var RetValue;
    try {
        RetValue = global.RunSmartMethod(glBlock0, Account.Value.Smart, Account, 0, 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;
};
global.HTTPCaller.DappInfo = function(Params, responce, ObjectOnly) {
    var SmartNum = global.ParseNum(Params.Smart);
    if (global.TX_PROCESS && global.TX_PROCESS.Worker)
        global.TX_PROCESS.Worker.send({ cmd: "SetSmartEvent", Smart: SmartNum });
    var Account;
    var Smart = global.DApps.Smart.ReadSimple(SmartNum);
    if (Smart) {
        delete Smart.HTML;
        delete Smart.Code;
        Account = global.DApps.Accounts.ReadState(Smart.Account);
        try {
            Account.SmartState = global.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 = global.HTTPCaller.DappWalletList(Params);
    var ArrLog = [];
    for (var i = 0; i < global.ArrLogClient.length; i++) {
        var Item = global.ArrLogClient[i];
        if (!Item.final)
            continue;
        ArrLog.push(Item);
    }
    var Ret: any = {
        result: 1, DELTA_CURRENT_TIME: global.DELTA_CURRENT_TIME, MIN_POWER_POW_TR: global.MIN_POWER_POW_TR, FIRST_TIME_BLOCK: global.FIRST_TIME_BLOCK,
        CONSENSUS_PERIOD_TIME: global.CONSENSUS_PERIOD_TIME, PRICE_DAO: global.PRICE_DAO(global.SERVER.BlockNumDB), NEW_SIGN_TIME: global.NEW_SIGN_TIME, Smart: Smart,
        Account: Account, ArrWallet: WLData.arr, ArrEvent: EArr, ArrLog: ArrLog,
    };
    if (global.WALLET) {
        Ret.WalletIsOpen = (global.WALLET.WalletOpen !== false);
        Ret.WalletCanSign = (global.WALLET.WalletOpen !== false && global.WALLET.KeyPair.WasInit);
        Ret.PubKey = global.WALLET.KeyPair.PubKeyStr;
    }
    if (!ObjectOnly) {
        Ret.CurTime = Date.now();
        Ret.CurBlockNum = global.GetCurrentBlockNumByTime();
        Ret.BlockNumDB = global.SERVER.BlockNumDB;
        Ret.MaxAccID = global.DApps.Accounts.GetMaxAccount();
        Ret.MaxDappsID = global.DApps.Smart.GetMaxNum();
    }
    return Ret;
};
global.HTTPCaller.DappWalletList = function(Params) {
    var arr0 = global.DApps.Accounts.GetWalletAccountsByMap(global.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: any = { result: 1, arr: arr, };
    return Ret;
};
global.HTTPCaller.DappAccountList = function(Params) {
    var arr = global.DApps.Accounts.GetRowsAccounts(Params.StartNum, Params.CountNum, undefined, 1);
    return { arr: arr, result: 1 };
};
global.HTTPCaller.DappSmartList = function(Params) {
    var arr = global.DApps.Smart.GetRows(Params.StartNum, Params.CountNum, undefined, undefined, Params.GetAllData, Params.TokenGenerate);
    return { arr: arr, result: 1 };
};
global.HTTPCaller.DappBlockList = function(Params, response) {
    Params.Filter = undefined;
    return global.HTTPCaller.GetBlockList(Params, response, 1);
};
global.HTTPCaller.DappTransactionList = function(Params, response) {
    Params.Filter = undefined;
    Params.Param3 = Params.BlockNum;
    return global.HTTPCaller.GetTransactionAll(Params, response);
};
var sessionid = global.GetHexFromAddres(crypto.randomBytes(20));
global.HTTPCaller.RestartNode = function(Params) {
    global.RestartNode();
    return { result: 1 };
};
global.HTTPCaller.ToLogServer = function(Str) {
    global.ToLogClient(Str);
    return { result: 1 };
};
global.HTTPCaller.FindMyAccounts = function(Params) {
    global.WALLET.FindMyAccounts(1);
    return { result: 1 };
};
global.HTTPCaller.GetAccount = function(id) {
    id = parseInt(id);
    var arr = global.DApps.Accounts.GetRowsAccounts(id, 1);
    return { Item: arr[0], result: 1 };
};
global.HTTPCaller.GetAccountList = function(Params) {
    if (!Params.CountNum)
        Params.CountNum = 1;
    var arr = global.DApps.Accounts.GetRowsAccounts(Params.StartNum, Params.CountNum, Params.Filter);
    return { arr: arr, result: 1 };
};
global.HTTPCaller.GetDappList = function(Params) {
    if (!Params.CountNum)
        Params.CountNum = 1;
    var arr = global.DApps.Smart.GetRows(Params.StartNum, Params.CountNum, Params.Filter, Params.Filter2, 1);
    return { arr: arr, result: 1 };
};
global.HTTPCaller.GetBlockList = function(Params, response, bOnlyNum) {
    if (!Params.CountNum)
        Params.CountNum = 1;
    if (Params.StartNum < global.SERVER.BlockNumDBMin) {
        let CountWait = 0;
        var WasWait = 0;
        for (var BlockNum = Params.StartNum; BlockNum < Params.StartNum + Params.CountNum; BlockNum++) {
            var Block = global.SERVER.ReadBlockHeaderDB(BlockNum);
            if (!Block) {
                CountWait++;
                WasWait = 1;
                global.LoadBlockFromNetwork({ BlockNum: BlockNum }, function(Err, Block) {
                    CountWait--;
                    if (CountWait === 0) {
                        var arr = global.SERVER.GetRows(Params.StartNum, Params.CountNum, Params.Filter);
                        var Result: any = { arr: arr, result: 1 };
                        response.end(JSON.stringify(Result));
                    }
                });
            }
        }
        if (WasWait)
            return null;
    }
    var arr = global.SERVER.GetRows(Params.StartNum, Params.CountNum, Params.Filter, !bOnlyNum);
    return { arr: arr, result: 1 };
};
global.HTTPCaller.GetTransactionAll = function(Params, response) {
    if (!Params.CountNum)
        Params.CountNum = 1;
    var BlockNum = Params.Param3;
    if (BlockNum < global.SERVER.BlockNumDBMin) {
        var Block = global.SERVER.ReadBlockHeaderDB(BlockNum);
        if (!Block) {
            global.LoadBlockFromNetwork({ BlockNum: BlockNum }, function(Err, Block) {
                var Result;
                if (Err) {
                    Result = { arr: [], result: 0 };
                }
                else {
                    var arr = global.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 = global.SERVER.GetTrRows(BlockNum, Params.StartNum, Params.CountNum, Params.Filter);
    return { arr: arr, result: 1 };
};
global.HTTPCaller.GetActList = function(Params) {
    var arr = global.DApps.Accounts.GetActList(Params.StartNum, Params.CountNum, Params.Filter);
    return { arr: arr, result: 1 };
};
global.HTTPCaller.GetHashList = function(Params) {
    var arr = global.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 * global.PERIOD_ACCOUNT_HASH;
        item.Hash100 = [];
        if (item.BlockNum % 100 === 0) {
            var Data = global.SERVER.DBHeader100.Read(item.BlockNum / 100);
            if (Data)
                item.Hash100 = Data.Hash100;
        }
    }
    return { arr: arr, result: 1 };
};
global.HTTPCaller.GetHistoryAct = function(Params) {
    var arr = global.WALLET.GetHistory(Params.StartNum, Params.CountNum, Params.Filter);
    return { arr: arr, result: 1 };
};
var LastTimeGetHashRate = 0;
var LastHashRate = 0;
var HashRateOneSec = 0;
global.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 = global.DApps.Accounts.DBStateTX.Read(0);
    var TXBlockNum = 0;
    if (StateTX)
        TXBlockNum = StateTX.BlockNum;
    var Ret: any = {
        result: 1,
        WalletOpen: global.WALLET.WalletOpen,
        WalletIsOpen: (global.WALLET.WalletOpen !== false),
        WalletCanSign: (global.WALLET.WalletOpen !== false && global.WALLET.KeyPair.WasInit),
        CODE_VERSION: global.CODE_VERSION,
        MAX_TRANSACTION_LIMIT: global.MAX_TRANSACTION_LIMIT,
        VersionNum: global.UPDATE_CODE_VERSION_NUM,
        RelayMode: global.SERVER.RelayMode,
        BlockNumDB: global.SERVER.BlockNumDB,
        CurBlockNum: global.GetCurrentBlockNumByTime(),
        CurTime: Date.now(),
        IsDevelopAccount: global.IsDeveloperAccount(global.WALLET.PubKeyArr),
        AccountMap: global.WALLET.AccountMap,
        ArrLog: global.ArrLogClient,
        MaxAccID: global.DApps.Accounts.GetMaxAccount(),
        MaxActNum: global.DApps.Accounts.GetActsMaxNum(),
        MaxDappsID: global.DApps.Smart.GetMaxNum(),
        NeedRestart: global.NeedRestart,
        ip: global.SERVER.ip,
        port: global.SERVER.port,
        NET_WORK_MODE: global.NET_WORK_MODE,
        INTERNET_IP_FROM_STUN: global.INTERNET_IP_FROM_STUN,
        HistoryMaxNum: MaxHistory,
        DELTA_CURRENT_TIME: global.DELTA_CURRENT_TIME,
        FIRST_TIME_BLOCK: global.FIRST_TIME_BLOCK,
        CONSENSUS_PERIOD_TIME: global.CONSENSUS_PERIOD_TIME,
        NEW_SIGN_TIME: global.NEW_SIGN_TIME,
        DATA_PATH: (global.DATA_PATH.substr(1, 1) === ":" ? global.DATA_PATH : global.GetNormalPathString(process.cwd() + "/" + global.DATA_PATH)),
        NodeAddrStr: global.SERVER.addrStr,
        STAT_MODE: global.STAT_MODE,
        HTTPPort: global.HTTP_PORT_NUMBER,
        HTTPPassword: global.HTTP_PORT_PASSWORD,
        CONSTANTS: Constants,
        CheckPointBlockNum: global.CHECK_POINT.BlockNum,
        MiningAccount: global.GENERATE_BLOCK_ACCOUNT,
        CountMiningCPU: global.GetCountMiningCPU(),
        CountRunCPU: global.ArrMiningWrk.length,
        MiningPaused: global.MiningPaused,
        HashRate: HashRateOneSec,
        MIN_POWER_POW_TR: global.MIN_POWER_POW_TR,
        PRICE_DAO: global.PRICE_DAO(global.SERVER.BlockNumDB),
        NWMODE: global.NWMODE,
        PERIOD_ACCOUNT_HASH: global.PERIOD_ACCOUNT_HASH,
        MAX_ACCOUNT_HASH: global.DApps.Accounts.DBAccountsHash.GetMaxNum(),
        TXBlockNum: TXBlockNum,
        SpeedSignLib: global.SpeedSignLib,
    };
    if (Params.Account)
        Ret.PrivateKey = global.GetHexFromArr(global.WALLET.GetPrivateKey(global.WALLET.AccountMap[Params.Account]));
    else
        Ret.PrivateKey = global.GetHexFromArr(global.WALLET.GetPrivateKey());
    Ret.PublicKey = global.WALLET.KeyPair.PubKeyStr;
    return Ret;
};
global.HTTPCaller.GetCurrentInfo = global.HTTPCaller.GetWalletInfo;
global.HTTPCaller.TestSignLib = function() {
    global.TestSignLib();
};
global.HTTPCaller.GetWalletAccounts = function() {
    var Ret: any = { result: 1, arr: global.DApps.Accounts.GetWalletAccountsByMap(global.WALLET.AccountMap), };
    Ret.PrivateKey = global.WALLET.KeyPair.PrivKeyStr;
    Ret.PublicKey = global.WALLET.KeyPair.PubKeyStr;
    return Ret;
};
global.HTTPCaller.SetWalletKey = function(PrivateKeyStr) {
    global.WALLET.SetPrivateKey(PrivateKeyStr, true);
    return { result: 1 };
};
global.HTTPCaller.SetWalletPasswordNew = function(Password) {
    global.WALLET.SetPasswordNew(Password);
    return { result: 1 };
};
global.HTTPCaller.OpenWallet = function(Password) {
    var res = global.WALLET.OpenWallet(Password);
    return { result: res };
};
global.HTTPCaller.CloseWallet = function() {
    var res = global.WALLET.CloseWallet();
    return { result: res };
};
global.HTTPCaller.GetSignTransaction = function(TR) {
    var Sign = global.WALLET.GetSignTransaction(TR);
    return { Sign: Sign, result: 1 };
};
global.HTTPCaller.GetSignFromHEX = function(Params) {
    var Arr = global.GetArrFromHex(Params.Hex);
    var Sign;
    if (Params.Account)
        Sign = global.WALLET.GetSignFromArr(Arr, global.WALLET.AccountMap[Params.Account]);
    else
        Sign = global.WALLET.GetSignFromArr(Arr);
    return { Sign: Sign, result: 1 };
};
global.HTTPCaller.SendTransactionHex = function(Params) {
    var body = global.GetArrFromHex(Params.Hex);
    var Result: any = { result: 1 };
    var Res = global.SERVER.AddTransactionOwn({ body: body, ToAll: 1 });
    Result.sessionid = sessionid;
    Result.text = global.AddTrMap[Res];
    var final = false;
    if (Res <= 0 && Res !== - 3)
        final = true;
    global.ToLogClient("Send: " + Result.text, global.GetHexFromArr(global.sha3(body)), final);
    return Result;
};
global.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, undefined, 4);
        }
        catch (e) {
            Result = "" + e;
        }
    }
    var Struct = { result: 1, sessionid: sessionid, text: Result };
    return Struct;
};
global.HTTPCaller.SetMining = function(MiningAccount) {
    global.WALLET.SetMiningAccount(parseInt(MiningAccount));
    return { result: 1 };
};

function CheckCorrectDevKey() {
    if (global.WALLET.WalletOpen === false) {
        var StrErr = "Not open wallet";
        global.ToLogClient(StrErr);
        return { result: 0, text: StrErr };
    }
    if (!global.IsDeveloperAccount(global.WALLET.PubKeyArr)) {
        var StrErr = "Not developer key";
        global.ToLogClient(StrErr);
        return { result: 0, text: StrErr };
    }
    return true;
};
global.HTTPCaller.SendECode = function(Param) {
    var Ret = CheckCorrectDevKey();
    if (Ret !== true)
        return Ret;
    if (Param.All) {
        global.SERVER.ConnectToAll();
        var arr = global.SERVER.GetActualNodes();
        for (var i = 0; i < arr.length; i++) {
            var Node = arr[i];
            global.SERVER.SendECode(Param, Node);
        }
        return { result: 1, text: "Sent to " + arr.length + " nodes" };
    }
    var Node = global.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" };
    global.SERVER.SendECode(Param, Node);
    return { result: 1, text: "Send" };
};
global.HTTPCaller.SetCheckPoint = function(BlockNum) {
    var Ret = CheckCorrectDevKey();
    if (Ret !== true)
        return Ret;
    if (!BlockNum)
        BlockNum = global.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 (global.WALLET.WalletOpen === false)
        return 0;
    var Block = global.SERVER.ReadBlockHeaderDB(BlockNum);
    if (!Block)
        return 0;
    var SignArr = global.arr2(Block.Hash, global.GetArrFromValue(Block.BlockNum));
    var Sign = secp256k1.sign(global.SHA3BUF(SignArr, Block.BlockNum), global.WALLET.KeyPair.getPrivateKey('')).signature;
    global.CHECK_POINT = { BlockNum: BlockNum, Hash: Block.Hash, Sign: Sign };
    global.SERVER.ResetNextPingAllNode();
    return 1;
};
global.SetCheckPointOnBlock = SetCheckPointOnBlock;
var idSetTimeSetCheckPoint;
global.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 (!global.SERVER.BlockNumDB)
        return;
    if (global.SERVER.BlockNumDB < 2100000)
        return;
    var Delta = global.GetCurrentBlockNumByTime() - global.SERVER.BlockNumDB;
    if (Delta > 16)
        return;
    var BlockNum = global.SERVER.BlockNumDB - global.CheckPointDelta;
    var Block = global.SERVER.ReadBlockHeaderDB(BlockNum);
    if (Block) {
        var Power = global.GetPowPower(Block.PowHash);
        if (Power < 30) {
            global.ToLog("CANNOT SET CHECK POINT Power=" + Power + "  BlockNum=" + BlockNum);
            return;
        }
        CountCheckPow++;
        SumCheckPow += Power;
        var AvgPow = SumCheckPow / CountCheckPow;
        if (CountCheckPow > 10) {
            if (Power < AvgPow - 2) {
                global.ToLog("**************** CANNOT SET CHECK POINT Power=" + Power + "/" + AvgPow + "  BlockNum=" + BlockNum);
                return;
            }
        }
        SetCheckPointOnBlock(BlockNum);
        global.ToLog("SET CHECK POINT Power=" + Power + "/" + AvgPow + "  BlockNum=" + BlockNum);
    }
};
global.HTTPCaller.SetNewCodeVersion = function(Data) {
    var Ret: any = CheckCorrectDevKey();
    if (Ret !== true)
        return Ret;
    var Ret = global.SERVER.SetNewCodeVersion(Data, global.WALLET.KeyPair.getPrivateKey(''));
    global.SERVER.ResetNextPingAllNode();
    return { result: 1, text: Ret };
};
global.HTTPCaller.SetCheckNetConstant = function(Data) {
    var Ret: any = CheckCorrectDevKey();
    if (Ret !== true)
        return Ret;
    if (!Data) {
        global.ToLogClient("Data not set");
        return { result: 0, text: "Data not set" };
    }
    Data.Num = global.GetCurrentBlockNumByTime();
    Data.BlockNum = global.GetCurrentBlockNumByTime() + 10;
    var SignArr = global.SERVER.GetSignCheckNetConstant(Data);
    Data.Sign = secp256k1.sign(global.SHA3BUF(SignArr), global.WALLET.KeyPair.getPrivateKey('')).signature;
    global.SERVER.CheckNetConstant({ NetConstant: Data }, { addrStr: "local" });
    global.SERVER.ResetNextPingAllNode();
    return { result: 1, text: "Set NET_CONSTANT BlockNum=" + Data.BlockNum };
};
global.HTTPCaller.SetCheckDeltaTime = function(Data) {
    var Ret = CheckCorrectDevKey();
    if (Ret !== true)
        return Ret;
    if (!Data || !Data.Num) {
        global.ToLogClient("Num not set");
        return { result: 0 };
    }
    var SignArr = global.SERVER.GetSignCheckDeltaTime(Data);
    Data.Sign = secp256k1.sign(global.SHA3BUF(SignArr), global.WALLET.KeyPair.getPrivateKey('')).signature;
    global.CHECK_DELTA_TIME = Data;
    global.SERVER.ResetNextPingAllNode();
    return { result: 1, text: "Set check time Num=" + Data.Num };
};
var idAutoCorrTime;
global.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 (global.WALLET.WalletOpen === false)
        return;
    if (global.GetCurrentBlockNumByTime() > StartCheckTimeNum && Math.abs(global.DELTA_CURRENT_TIME) >= 120) {
        var AutoDelta = - Math.trunc(global.DELTA_CURRENT_TIME);
        var Data: any = { Num: global.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 = global.SERVER.GetSignCheckDeltaTime(Data);
        Data.Sign = secp256k1.sign(global.SHA3BUF(SignArr), global.WALLET.KeyPair.getPrivateKey('')).signature;
        global.CHECK_DELTA_TIME = Data;
        global.SERVER.ResetNextPingAllNode();
        StartCheckTimeNum = Data.EndBlockNum + 1;
        global.ToLog("Auto corr time Num:" + Data.Num + " AutoDelta=" + AutoDelta);
    }
};
global.HTTPCaller.SaveConstant = function(SetObj) {
    var WasUpdate = global.USE_AUTO_UPDATE;
    for (var key in SetObj) {
        global[key] = SetObj[key];
    }
    global.SAVE_CONST(true);
    global.SERVER.DO_CONSTANT();
    if (!WasUpdate && global.USE_AUTO_UPDATE && global.CODE_VERSION.VersionNum && global.UPDATE_CODE_VERSION_NUM < global.CODE_VERSION.VersionNum) {
        global.SERVER.UseCode(global.CODE_VERSION.VersionNum, true);
    }
    if (SetObj.DoRestartNode)
        global.RestartNode();
    else {
        if (SetObj.DoMining)
            global.RunStopPOWProcess();
    }
    return { result: 1 };
};
global.HTTPCaller.SetHTTPParams = function(SetObj) {
    global.HTTP_PORT_NUMBER = SetObj.HTTPPort;
    global.HTTP_PORT_PASSWORD = SetObj.HTTPPassword;
    global.SAVE_CONST(true);
    if (SetObj.DoRestartNode)
        global.RestartNode();
    return { result: 1 };
};
global.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 (global.NET_WORK_MODE) {
        global.START_IP = global.NET_WORK_MODE.ip;
        global.START_PORT_NUMBER = global.NET_WORK_MODE.port;
    }
    global.SAVE_CONST(true);
    if (SetObj.DoRestartNode)
        global.RestartNode();
    return { result: 1 };
};
global.HTTPCaller.GetAccountKey = function(Num) {
    var Result: any = {};
    Result.result = 0;
    var KeyPair = global.WALLET.GetAccountKey(Num);
    if (KeyPair) {
        Result.result = 1;
        Result.PubKeyStr = global.GetHexFromArr(KeyPair.getPublicKey('', 'compressed'));
    }
    return Result;
};
global.HTTPCaller.GetHotArray = function(Param) {
    var ArrTree = global.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 = global.SERVER.CurrentBlockNum - Param.CountBlock; i <= global.SERVER.CurrentBlockNum - Param.CountBlock; i++) {
            var Block = global.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,
        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: global.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;
};
global.HTTPCaller.GetBlockchainStat = function(Param) {
    var Result = global.SERVER.GetStatBlockchainPeriod(Param);
    Result.result = 1;
    Result.sessionid = sessionid;
    return Result;
};
global.HTTPCaller.GetAllCounters = function(Params, response) {
    let Result = global.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;
        }
    }
};
global.HTTPCaller.SetStatMode = function(flag) {
    if (flag)
        global.StartCommonStat();
    global.STAT_MODE = flag;
    global.SAVE_CONST(true);
    global.TX_PROCESS.RunRPC("LOAD_CONST");
    return { result: 1, sessionid: sessionid, STAT_MODE: global.STAT_MODE };
};
global.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 };
};
global.HTTPCaller.RewriteAllTransactions = function(Param) {
    global.RewriteAllTransactions();
    return { result: 1, sessionid: sessionid };
};
global.HTTPCaller.RewriteTransactions = function(Param) {
    var Ret = global.SERVER.ReWriteDAppTransactions(Param.BlockCount);
    return { result: Ret, sessionid: sessionid };
};
global.HTTPCaller.TruncateBlockChain = function(Param) {
    var StartNum = global.SERVER.BlockNumDB - Param.BlockCount;
    var MinBlock = global.DApps.Accounts.GetMinBlockAct();
    if (MinBlock > StartNum) {
        global.ToLog("Cant Truncate BlockChain. Very long length. Max length=" + (global.SERVER.BlockNumDB - MinBlock), 0);
        return { result: 0, sessionid: sessionid };
    }
    global.SERVER.TruncateBlockDB(StartNum);
    return { result: 1, sessionid: sessionid };
};
global.HTTPCaller.ClearDataBase = function(Param) {
    BlockTree.Clear();
    global.SERVER.ClearDataBase();
    return { result: 1, sessionid: sessionid };
};
global.HTTPCaller.CleanChain = function(Param) {
    if (global.CleanChain) {
        var StartNum = global.SERVER.BlockNumDB - Param.BlockCount;
        global.CleanChain(StartNum);
        return { result: 1, sessionid: sessionid };
    }
    return { result: 0, sessionid: sessionid };
};
global.HTTPCaller.GetArrStats = function(Keys, response) {
    var arr = global.GET_STATDIAGRAMS(Keys);
    let Result: any = { 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;
};
global.HTTPCaller.GetBlockChain = function(type) {
    if (!global.SERVER || !global.SERVER.LoadedChainList) {
        return { result: 0 };
    }
    var MainChains = {};
    for (var i = 0; i < global.SERVER.LoadedChainList.length; i++) {
        var chain = global.SERVER.LoadedChainList[i];
        if (chain && !chain.Deleted)
            MainChains[chain.id] = true;
    }
    var arrBlocks = [];
    var arrLoadedChainList = [];
    var arrLoadedBlocks = [];
    for (var key in global.SERVER.BlockChain) {
        var Block = global.SERVER.BlockChain[key];
        if (Block) {
            arrBlocks.push(CopyBlockDraw(Block, MainChains));
        }
    }
    AddChainList(arrLoadedChainList, global.SERVER.LoadedChainList, true);
    AddMapList(arrLoadedBlocks, type, global.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: any = {
        LastCurrentBlockNum: global.SERVER.GetLastCorrectBlockNum(), CurrentBlockNum: global.SERVER.CurrentBlockNum, LoadedChainList: arrLoadedChainList,
        LoadedBlocks: arrLoadedBlocks, BlockChain: arrBlocks, port: global.SERVER.port, DELTA_CURRENT_TIME: global.DELTA_CURRENT_TIME, memoryUsage: process.memoryUsage(),
        IsDevelopAccount: global.IsDeveloperAccount(global.WALLET.PubKeyArr), LoadedChainCount: global.SERVER.LoadedChainList.length, StartLoadBlockTime: global.SERVER.StartLoadBlockTime,
        sessionid: sessionid, result: 1
    };
    var obj2: any = global.HTTPCaller.GetHotArray();
    obj.ArrTree = obj2.ArrTree;
    arrBlocks = [];
    arrLoadedChainList = [];
    arrLoadedBlocks = [];
    return obj;
};
global.HTTPCaller.GetHistoryTransactions = function(Params) {
    if (typeof Params === "object" && Params.AccountID) {
        var Account = global.DApps.Accounts.ReadState(Params.AccountID);
        if (!Account)
            return { result: 0 };
        if (!Params.Count)
            Params.Count = 100;
        var arr = global.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 = global.SERVER.ReadBlockDB(Item.BlockNum);
                if (!Block || (!Block.arrContent))
                    continue;
                var Body = Block.arrContent[Item.TrNum];
                if (!Body)
                    continue;
                var TR = global.DApps.Accounts.GetObjectTransaction(Body);
                if (TR)
                    Item.Description = TR.Description;
            }
        }
        var Result: any = {
            Value: {
                SumCOIN: Account.Value.SumCOIN,
                SumCENT: Account.Value.SumCENT
            },
            Name: Account.Name,
            Currency: Account.Currency,
            MaxBlockNum: global.GetCurrentBlockNumByTime(),
            FIRST_TIME_BLOCK: global.FIRST_TIME_BLOCK,
            result: arr.length > 0 ? 1 : 0,
            History: arr
        };
        return Result;
    }
    return { result: 0 };
};

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

function GetHexFromAddresShort(Hash) {
    return global.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 = global.ReadUintFromArr(Block.AddrHash, 0);
        MinerID = Num;
        var Item = global.DApps.Accounts.ReadState(Num);
        if (Item && Item.Name)
            MinerName = Item.Name.substr(0, 8);
    }
    var CheckPoint = 0;
    if (Block.BlockNum === global.CHECK_POINT.BlockNum)
        CheckPoint = 1;
    var Mining;
    if (global.SERVER.MiningBlock === Block)
        Mining = 1;
    else
        Mining = 0;
    GetGUID(Block);
    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: global.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: any = {
        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);
    if (type.substr(0, 1) === ".")
        type = type.substr(1);
    var 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 === "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") {
        data = GetFileHTMLWithParsing(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) {
                //@ts-ignore
                global.ToLog("Error teg " + TagName + " in " + Path);
                break;
            }
            var Delta = index2 - index;
            if (Delta > 210) {
                //@ts-ignore
                global.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 SaveFileSimple(Path, Str) {
    global.SendHTMLMap = {};
    var Key = "GetFileSimple-" + Path;
    global.SendHTMLMap[Key] = Str;
    global.SaveToFile(Path, Str);
};
global.SendHTMLMap = {};
global.SendWebFile = SendWebFile;
global.GetFileHTMLWithParsing = GetFileHTMLWithParsing;
global.GetFileHTMLFromMarkdown = GetFileHTMLFromMarkdown;
global.GetFileSimple = GetFileSimple;
global.SaveFileSimple = SaveFileSimple;

function GetStrTime(now) {
    if (!now)
        now = global.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 = global.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 (arguments && arguments[0] && arguments[0].length) {
                    global.ADD_TO_STAT("HTTP_SEND", arguments[0].length);
                }
                response._end.apply(response, arguments);
            }
            catch (e) {
                global.ToError("H##1");
                global.ToError(e);
            }
        };
        response.writeHead = function() {
            try {
                response._writeHead.apply(response, arguments);
            }
            catch (e) {
                global.ToError("H##2");
                global.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;
            global.ToLog("CONNECT TO HTTP ACCESS FROM: " + remoteAddress, 0);
            global.ToLog("Path: " + Path, 0);
        }
        if (CheckPassword && global.HTTP_PORT_PASSWORD) {
            var StrPort: any = "";
            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 = global.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 = global.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) {
                    global.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, global.LISTEN_IP, function() {
        global.HTTP_SERVER_START_OK = 1;
        global.ToLog("Run HTTP-server on " + global.LISTEN_IP + ":" + port);
    });
    HTTPServer.on('error', function(err) {
        global.ToError("H##3");
        global.ToError(err);
    });
}
if (global.ELECTRON) {
    const ipcMain = require('electron').ipcMain;
    ipcMain.on('GetData', function(event, arg) {
        event.returnValue = OnGetData(arg);
    });
}
exports.SendData = OnGetData;
//@ts-ignore
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 };
        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;
};
global.HTTPCaller.GetHashRate = function(ArrParams) {
    var CurBlockNum = global.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 = 10;
        if (i === ArrParams.length - 1)
            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 = global.SERVER.ReadBlockHeaderDB(Num + d);
                    if (Block) {
                        CountSum++;
                        Sum += global.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 };
};