// Supporting functions
void free_msg_head_fields(syslog_msg_head *head) {
    if (head->timestamp != NULL) {
        cstr_free(head->timestamp);
        head->timestamp = NULL;
    }

    if (head->hostname != NULL) {
        cstr_free(head->hostname);
        head->hostname = NULL;
    }

    if (head->appname != NULL) {
        cstr_free(head->appname);
        head->appname = NULL;
    }

    if (head->processid != NULL) {
        cstr_free(head->processid);
        head->processid = NULL;
    }

    if (head->messageid != NULL) {
        cstr_free(head->messageid);
        head->messageid = NULL;
    }
}

cstring *ser_wallet(const struct wallet *wlt)
{
	struct bp_key *key;

	cstring *rs = cstr_new_sz(20 * 1024);

	/*
	 * ser "root" record
	 */
	{
	cstring *s_root = ser_wallet_root(wlt);
	cstring *recdata = message_str(wlt->chain->netmagic,
				       "root", s_root->str, s_root->len);
	cstr_append_buf(rs, recdata->str, recdata->len);
	cstr_free(recdata, true);
	cstr_free(s_root, true);
	}

	/* ser "privkey" records */
	wallet_for_each_key(wlt, key) {
		void *privkey = NULL;
		size_t pk_len = 0;

		bp_privkey_get(key, &privkey, &pk_len);

		cstring *recdata = message_str(wlt->chain->netmagic,
					       "privkey",
					       privkey, pk_len);
		free(privkey);

		cstr_append_buf(rs, recdata->str, recdata->len);
		cstr_free(recdata, true);
	}

static void tl_expression_free (struct tl_expression *E) {
  cstr_free (&E->text);
  cstr_free (&E->right_name);
  tl_list_token_free (E->left); E->left = NULL;
  tl_list_token_free (E->right); E->right = NULL;
  zfree (E, sizeof (*E));
}

static void runtest(bool is_valid, const char *basefn)
{
	char *fn = test_filename(basefn);
	json_t *tests = read_json(fn);
	assert(json_is_array(tests));

	unsigned int idx;
	for (idx = 0; idx < json_array_size(tests); idx++) {
		json_t *test = json_array_get(tests, idx);
		assert(json_is_array(test));

		const char *scriptSigEnc =
			json_string_value(json_array_get(test, 0));
		const char *scriptPubKeyEnc =
			json_string_value(json_array_get(test, 1));
		assert(scriptSigEnc != NULL);
		assert(scriptPubKeyEnc != NULL);

		cstring *scriptSig = parse_script_str(scriptSigEnc);
		cstring *scriptPubKey = parse_script_str(scriptPubKeyEnc);
		assert(scriptSig != NULL);
		assert(scriptPubKey != NULL);

		test_script(is_valid, scriptSig, scriptPubKey,
			    idx, scriptSigEnc, scriptPubKeyEnc);

		cstr_free(scriptSig, true);
		cstr_free(scriptPubKey, true);
	}

	json_decref(tests);
	free(fn);
}

static void test_privkey_valid_enc(const char *base58_str,
				cstring *payload,
				bool compress, bool is_testnet)
{
	assert(payload != NULL);

	cstring *pl = cstr_new_sz(payload->len + 1);
	cstr_append_buf(pl, payload->str, payload->len);
	if (compress)
		cstr_append_c(pl, 1);

	cstring *b58 = base58_encode_check(
		is_testnet ? PRIVKEY_ADDRESS_TEST : PRIVKEY_ADDRESS, true,
		pl->str, pl->len);
	assert(b58 != NULL);
	if (strcmp(b58->str, base58_str)) {
		fprintf(stderr, "base58: have %s, expected %s\n",
			b58->str, base58_str);
		assert(!strcmp(b58->str, base58_str));
	}

	cstr_free(b58, true);
	cstr_free(pl, true);
	cstr_free(payload, true);
}

void test_examples()
{
    cstring *value;
    cstring *key;
    logdb_log_db *db;
    enum logdb_error error = 0;
    int create_database = 1;

    /* create a new database object */
    db = logdb_new();

    /* create a database file (will overwrite existing) */
    logdb_load(db, "/tmp/test.logdb", create_database, &error);

    /* append a record */
    value = cstr_new("testkey");
    key = cstr_new("somevalue");
    /* second parameter NULL means we don't use a transaction */
    logdb_append(db, NULL, key, value);

    /* flush database (write its state to disk) */
    logdb_flush(db);

    /* cleanup */
    logdb_free(db);
    cstr_free(key, true);
    cstr_free(value, true);
}

void btc_node_send_version(btc_node *node)
{
    if (!node)
        return;

    /* get new string buffer */
    cstring *version_msg_cstr = cstr_new_sz(256);

    /* copy socket_addr to p2p addr */
    btc_p2p_address fromAddr;
    btc_p2p_address_init(&fromAddr);
    btc_p2p_address toAddr;
    btc_p2p_address_init(&toAddr);
    btc_addr_to_p2paddr(&node->addr, &toAddr);

    /* create a version message struct */
    btc_p2p_version_msg version_msg;
    memset(&version_msg, 0, sizeof(version_msg));

    /* create a serialized version message */
    btc_p2p_msg_version_init(&version_msg, &fromAddr, &toAddr, node->nodegroup->clientstr);
    btc_p2p_msg_version_ser(&version_msg, version_msg_cstr);

    /* create p2p message */
    cstring *p2p_msg = btc_p2p_message_new(node->nodegroup->chainparams->netmagic, BTC_MSG_VERSION, version_msg_cstr->str, version_msg_cstr->len);

    /* send message */
    btc_node_send(node, p2p_msg);

    /* cleanup */
    cstr_free(version_msg_cstr, true);
    cstr_free(p2p_msg, true);
}

static void test_privkey_valid_dec(const char *base58_str,
				cstring *payload,
				bool compress, bool is_testnet)
{
	assert(payload != NULL);

	cstring *pl = cstr_new_sz(payload->len + 1);
	cstr_append_buf(pl, payload->str, payload->len);
	if (compress)
		cstr_append_c(pl, 1);

	unsigned char addrtype;
	cstring *dec = base58_decode_check(&addrtype, base58_str);
	assert(dec != NULL);

	if (is_testnet)
		assert(addrtype == PRIVKEY_ADDRESS_TEST);
	else
		assert(addrtype == PRIVKEY_ADDRESS);

	if (compress) {
		assert(dec->len == 33);
		assert(dec->str[32] == 1);
	} else
		assert(dec->len == 32);

	assert(dec->len == pl->len);
	assert(memcmp(dec->str, pl->str, pl->len) == 0);

	cstr_free(dec, true);
	cstr_free(pl, true);
	cstr_free(payload, true);
}

static void test_extended_key()
{
	printf("TEST: test_extended_key\n");

	// Check we get sensible results when parsing some test vector data

	struct hd_extended_key pub;
	assert(hd_extended_key_init(&pub));
	{
		cstring *tv1data = base58_decode(s_tv1_m_xpub);
		assert(hd_extended_key_deser(&pub, tv1data->str, tv1data->len));
		cstr_free(tv1data, true);
	}

	struct hd_extended_key priv;
	assert(hd_extended_key_init(&priv));
	{
		cstring *tv1data = base58_decode(s_tv1_m_xprv);
		assert(hd_extended_key_deser(&priv, tv1data->str, tv1data->len));
		cstr_free(tv1data, true);
	}

	printf("PUB:\n");
	print_ek_public(&pub);

	printf("PRV:\n");
	print_ek_public(&priv);

	// Check we get the same codechains

	assert(0 == memcmp(pub.chaincode.data, priv.chaincode.data, 32));

	hd_extended_key_free(&priv);
	hd_extended_key_free(&pub);
}

static void load_json_key(json_t *wallet, struct bp_key *key)
{
	json_t *keys_a = json_object_get(wallet, "keys");
	assert(json_is_array(keys_a));

	json_t *key_o = json_array_get(keys_a, 0);
	assert(json_is_object(key_o));

	const char *address_str = json_string_value(json_object_get(key_o, "address"));
	assert(address_str != NULL);

	const char *privkey_address_str = json_string_value(json_object_get(key_o, "privkey_address"));
	assert(privkey_address_str);

	const char *pubkey_str = json_string_value(json_object_get(key_o, "pubkey"));
	assert(pubkey_str != NULL);

	const char *privkey_str = json_string_value(json_object_get(key_o, "privkey"));
	assert(privkey_str != NULL);

	char rawbuf[strlen(privkey_str)];
	size_t buf_len = 0;

	/* decode privkey */
	assert(decode_hex(rawbuf, sizeof(rawbuf), privkey_str, &buf_len) == true);

	assert(bp_privkey_set(key, rawbuf, buf_len) == true);

	/* decode pubkey */
	assert(decode_hex(rawbuf, sizeof(rawbuf), pubkey_str, &buf_len) == true);

	void *pk = NULL;
	size_t pk_len = 0;

	/* verify pubkey matches expected */
	assert(bp_pubkey_get(key, &pk, &pk_len) == true);
	assert(pk_len == buf_len);
	assert(memcmp(rawbuf, pk, pk_len) == 0);

	free(pk);

	/* verify pubkey hash (bitcoin address) matches expected */
	cstring *btc_addr = bp_pubkey_get_address(key, PUBKEY_ADDRESS_TEST);
	assert(strlen(address_str) == btc_addr->len);
	assert(memcmp(address_str, btc_addr->str, btc_addr->len) == 0);

	/* verify the private key address (WIF) */
	cstring *privkey_addr = bp_privkey_get_address(key, PRIVKEY_ADDRESS_TEST);
	assert(strlen(privkey_address_str) == privkey_addr->len);
	assert(memcmp(privkey_address_str, privkey_addr->str, privkey_addr->len) == 0);

	cstr_free(privkey_addr, true);
	cstr_free(btc_addr, true);
}

void logdb_record_free(logdb_record* rec)
{
    if (!rec)
        return;

    cstr_free(rec->key, true);
    cstr_free(rec->value, true);
    rec->next = NULL;
    rec->prev = NULL;

    free(rec);
}

static struct wallet *load_wallet(void)
{
	char *passphrase = getenv("PICOCOIN_PASSPHRASE");
	if (!passphrase) {
		fprintf(stderr, "missing PICOCOIN_PASSPHRASE\n");
		return NULL;
	}

	char *filename = wallet_filename();
	if (!filename) {
		fprintf(stderr, "wallet: no filename\n");
		return NULL;
	}

	cstring *data = read_aes_file(filename, passphrase, strlen(passphrase),
				      100 * 1024 * 1024);
	if (!data) {
		fprintf(stderr, "wallet: missing or invalid\n");
		return NULL;
	}

	struct wallet *wlt = calloc(1, sizeof(*wlt));
	if (!wlt) {
		fprintf(stderr, "wallet: failed to allocate wallet\n");
		cstr_free(data, true);
		return NULL;
	}

	if (!wallet_init(wlt, chain)) {
		free(wlt);
		cstr_free(data, true);
		return NULL;
	}

	struct const_buffer buf = { data->str, data->len };

	if (!deser_wallet(wlt, &buf))
		goto err_out;

	if (chain != wlt->chain) {
		fprintf(stderr, "wallet root: foreign chain detected, aborting load.  Try 'chain-set' first.\n");
		goto err_out;
	}

	return wlt;

err_out:
	fprintf(stderr, "wallet: invalid data found\n");
	wallet_free(wlt);
	cstr_free(data, true);
	return NULL;
}

static bool read_ek_ser_from_base58(const char *base58,
				    struct hd_extended_key_serialized *out)
{
	cstring *str = base58_decode(base58);
	if (str->len == 82) {
		memcpy(out->data, str->str, 78);
		cstr_free(str, true);
		return true;
	}

	cstr_free(str, true);
	return false;
}

int main() {
  cstr c = cstr_cat_printf(NULL, "sdsd");
  int i;
  printf("%d %d %s\n", cstr_used(c), cstr_cap(c), c);
  cstr_free(c);

  c = cstr_create(0);
  for(i = 1; i < 100000; i++)
    c = cstr_cat_char(c, i);

  printf("cap %d, used %d ", cstr_cap(c), cstr_used(c));
  cstr_free(c);
  return 0;
}

static void cb_conn_read_cli(struct bufferevent *bev, void *user_data)
{
    void*    buffer  = NULL;
    uint32_t buf_len = 0;
    struct evbuffer *buf_in = bufferevent_get_input(bev);
    cli_cmd_t cmd;
    cstr *json = cstr_new();

    cli_cmd_init(&cmd);

    /* bufferevent_lock(bev); */

    /* read data frome buffer in */
    buf_len = evbuffer_get_length(buf_in);
    buffer = calloc(1, buf_len);
    bufferevent_read(bev, buffer, buf_len);

    /* bufferevent_unlock(bev); */

    log_dbg("recv command: %s", (char*)buffer);
    cli_parse(&cmd, (char*)buffer);
    cli_cmd_to_json(&cmd, json);
    log_dbg("cli response: %s", cstr_body(json));

    bufferevent_send(bev, cstr_body(json), cstr_len(json) + 1);

    /* put data to addr recv buffer, and translate to command format */
    cli_cmd_release(&cmd);
    cstr_free(json);
    free(buffer);
    /* bufferevent_free(bev); */
}

/* cleanup all static data used during compilation */
static void tcc_cleanup(void)
{
	int i, n;
	if (NULL == tcc_state) {
		return;
	}
	tcc_state = NULL;

	/* free -D defines */
	free_defines (NULL);

	/* free tokens */
	n = tok_ident - TOK_IDENT;
	for (i = 0; i < n; i++) {
		free (table_ident[i]);
	}
	free (table_ident);

	/* free sym_pools */
	dynarray_reset (&sym_pools, &nb_sym_pools);
	/* string buffer */
	cstr_free (&tokcstr);
	/* reset symbol stack */
	sym_free_first = NULL;
	/* cleanup from error/setjmp */
	macro_ptr = NULL;
}

void node_periodical_timer(int fd, short event, void *ctx) {
    UNUSED(fd);
    UNUSED(event);
    btc_node *node = (btc_node *)ctx;
    uint64_t now = time(NULL);

    /* pass data to the callback and give it a chance to cancle the call */
    if (node->nodegroup->periodic_timer_cb)
        if (!node->nodegroup->periodic_timer_cb(node, &now))
            return;

    if (node->time_started_con+BTC_CONNECT_TIMEOUT_S < now && ((node->state & NODE_CONNECTING) == NODE_CONNECTING))
    {
        node->state = 0;
        node->time_started_con = 0;
        node->state |= NODE_ERRORED;
        node->state |= NODE_TIMEOUT;
        btc_node_connection_state_changed(node);
    }

    if ( ((node->state & NODE_CONNECTED) == NODE_CONNECTED) && node->lastping + BTC_PING_INTERVAL_S < now)
    {
        //time for a ping
        uint64_t nonce;
        btc_cheap_random_bytes((uint8_t *)&nonce, sizeof(nonce));
        cstring *pingmsg = btc_p2p_message_new(node->nodegroup->chainparams->netmagic, BTC_MSG_PING, &nonce, sizeof(nonce));
        btc_node_send(node, pingmsg);
        cstr_free(pingmsg, true);
        node->lastping = now;
    }
}

void cstr_split_l(cstring*c,char*data,int size,vector *v)
{
    int n,len=0;
    cstring *st,*tx;

    tx = cstr_new();
    cstr_set_c(tx,c);

    while(1){
        n = cstr_find_l(tx,0,data,size);
/*
         if (n == 0){
            len = n+size;
            cstr_set_l(tx,tx->data+len,tx->size-len);
            continue;
        }else if (n > -1){
*/
        if (n > -1){
            st = cstr_new();
            cstr_add_l(st,tx->data,n);
            vector_add(v,st);
            len = n+size;
            cstr_set_l(tx,tx->data+len,tx->size-len);
        }else{
            st = cstr_new();
            cstr_add_l(st,tx->data,tx->size);
            vector_add(v,st);
            break;
        }
    }
    cstr_free(tx);
}

static void test_decode(const char *hexstr, const char *base58_str)
{
	size_t hs_len = strlen(hexstr) / 2;
	unsigned char *raw = calloc(1, hs_len);
	size_t out_len;

	bool rc = decode_hex(raw, hs_len, hexstr, &out_len);
	if (!rc) {
		fprintf(stderr, "raw %p, sizeof(raw) %lu, hexstr %p %s\n",
			raw, hs_len, hexstr, hexstr);
		assert(rc);
	}

	cstring *s = base58_decode(base58_str);
	if (memcmp(s->str, raw, out_len < s->len ? out_len : s->len)) {
		dumphex("decode have", s->str, s->len);
		dumphex("decode want", raw, out_len);
		assert(memcmp(s->str, raw, out_len) == 0);
	}
	if (s->len != out_len) {
		fprintf(stderr, "decode len: have %u, want %u\n",
			(unsigned int) s->len,
			(unsigned int) out_len);
		dumphex("decode have", s->str, s->len);
		dumphex("decode want", raw, out_len);
		assert(s->len == out_len);
	}

	free(raw);
	cstr_free(s, true);
}

void bp_tx_sighash(bu256_t *hash, const cstring *scriptCode,
		   const struct bp_tx *txTo, unsigned int nIn,
		   int nHashType)
{
	if (nIn >= txTo->vin->len) {
		//  nIn out of range
		bu256_set_u64(hash, 1);
		return;
	}

	// Check for invalid use of SIGHASH_SINGLE
	if ((nHashType & 0x1f) == SIGHASH_SINGLE) {
		if (nIn >= txTo->vout->len) {
			//  nOut out of range
			bu256_set_u64(hash, 1);
			return;
		}
	}

	cstring *s = cstr_new_sz(512);

	// Serialize only the necessary parts of the transaction being signed
	bp_tx_sigserializer(s, scriptCode, txTo, nIn, nHashType);

	ser_s32(s, nHashType);
	bu_Hash((unsigned char *) hash, s->str, s->len);

	cstr_free(s, true);
}