// Copyright 2020 Coinbase, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package lbry

import (
	"fmt"
	"strings"

	"github.com/btcsuite/btcd/chaincfg"
	"github.com/lbryio/rosetta-sdk-go/types"
)

const (
	// Blockchain is lbry.
	Blockchain string = "lbry"

	// MainnetNetwork is the value of the network
	// in MainnetNetworkIdentifier.
	MainnetNetwork string = "Mainnet"

	// TestnetNetwork is the value of the network
	// in TestnetNetworkIdentifier.
	TestnetNetwork string = "Testnet3"

	// Decimals is the decimals value
	// used in Currency.
	Decimals = 8

	// SatoshisInlbry is the number of
	// Satoshis in 1 BTC (10^8).
	SatoshisInlbry = 100000000

	// InputOpType is used to describe
	// INPUT.
	InputOpType = "INPUT"

	// OutputOpType is used to describe
	// OUTPUT.
	OutputOpType = "OUTPUT"

	// CoinbaseOpType is used to describe
	// Coinbase.
	CoinbaseOpType = "COINBASE"

	// SuccessStatus is the status of all
	// lbry operations because anything
	// on-chain is considered successful.
	SuccessStatus = "SUCCESS"

	// SkippedStatus is the status of all
	// operations that are skipped because
	// of BIP-30. You can read more about these
	// types of operations in BIP-30.
	SkippedStatus = "SKIPPED"

	// TransactionHashLength is the length
	// of any transaction hash in lbry.
	TransactionHashLength = 64

	// NullData is returned by lbryd
	// as the ScriptPubKey.Type for OP_RETURN
	// locking scripts.
	NullData = "nulldata"
)

// Fee estimate constants
// Source: https://lbryops.org/en/tools/calc-size/
const (
	MinFeeRate            = float64(0.00001) // nolint:gomnd
	TransactionOverhead   = 12               // 4 version, 2 segwit flag, 1 vin, 1 vout, 4 lock time
	InputSize             = 68               // 4 prev index, 32 prev hash, 4 sequence, 1 script size, ~27 script witness
	OutputOverhead        = 9                // 8 value, 1 script size
	P2PKHScriptPubkeySize = 25               // P2PKH size
)

var (
	// MainnetGenesisBlockIdentifier is the genesis block for mainnet.
	MainnetGenesisBlockIdentifier = &types.BlockIdentifier{
		Hash: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
	}

	// MainnetParams are the params for mainnet.
	MainnetParams = &chaincfg.MainNetParams

	// MainnetCurrency is the *types.Currency for mainnet.
	MainnetCurrency = &types.Currency{
		Symbol:   "BTC",
		Decimals: Decimals,
	}

	// TestnetGenesisBlockIdentifier is the genesis block for testnet.
	TestnetGenesisBlockIdentifier = &types.BlockIdentifier{
		Hash: "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943",
	}

	// TestnetParams are the params for testnet.
	TestnetParams = &chaincfg.TestNet3Params

	// TestnetCurrency is the *types.Currency for testnet.
	TestnetCurrency = &types.Currency{
		Symbol:   "tBTC",
		Decimals: Decimals,
	}

	// OperationTypes are all supported operation.Types.
	OperationTypes = []string{
		InputOpType,
		OutputOpType,
		CoinbaseOpType,
	}

	// OperationStatuses are all supported operation.Status.
	OperationStatuses = []*types.OperationStatus{
		{
			Status:     SuccessStatus,
			Successful: true,
		},
		{
			Status:     SkippedStatus,
			Successful: false,
		},
	}
)

// ScriptPubKey is a script placed on the output operations
// of a lbry transaction that must be satisfied to spend
// the output.
type ScriptPubKey struct {
	ASM          string   `json:"asm"`
	Hex          string   `json:"hex"`
	RequiredSigs int64    `json:"reqSigs,omitempty"`
	Type         string   `json:"type"`
	Addresses    []string `json:"addresses,omitempty"`
}

// ScriptSig is a script on the input operations of a
// lbry transaction that satisfies the ScriptPubKey
// on an output being spent.
type ScriptSig struct {
	ASM string `json:"asm"`
	Hex string `json:"hex"`
}

// BlockchainInfo is information about the lbry network.
// This struct only contains the information necessary for
// this implementation.
type BlockchainInfo struct {
	Chain         string `json:"chain"`
	Blocks        int64  `json:"blocks"`
	BestBlockHash string `json:"bestblockhash"`
}

// PeerInfo is a collection of relevant info about a particular peer.
type PeerInfo struct {
	Addr           string `json:"addr"`
	Version        int64  `json:"version"`
	SubVer         string `json:"subver"`
	StartingHeight int64  `json:"startingheight"`
	RelayTxes      bool   `json:"relaytxes"`
	LastSend       int64  `json:"lastsend"`
	LastRecv       int64  `json:"lastrecv"`
	BanScore       int64  `json:"banscore"`
	SyncedBlocks   int64  `json:"synced_blocks"`
	SyncedHeaders  int64  `json:"synced_headers"`
}

// Block is a raw lbry block (with verbosity == 2).
type Block struct {
	Hash              string  `json:"hash"`
	Height            int64   `json:"height"`
	PreviousBlockHash string  `json:"previousblockhash"`
	Time              int64   `json:"time"`
	MedianTime        int64   `json:"mediantime"`
	Nonce             int64   `json:"nonce"`
	MerkleRoot        string  `json:"merkleroot"`
	Version           int32   `json:"version"`
	Size              int64   `json:"size"`
	Weight            int64   `json:"weight"`
	Bits              string  `json:"bits"`
	Difficulty        float64 `json:"difficulty"`

	Txs []*Transaction `json:"tx"`
}

// Metadata returns the metadata for a block.
func (b Block) Metadata() (map[string]interface{}, error) {
	m := &BlockMetadata{
		Nonce:      b.Nonce,
		MerkleRoot: b.MerkleRoot,
		Version:    b.Version,
		Size:       b.Size,
		Weight:     b.Weight,
		MedianTime: b.MedianTime,
		Bits:       b.Bits,
		Difficulty: b.Difficulty,
	}

	return types.MarshalMap(m)
}

// BlockMetadata is a collection of useful
// metadata in a block.
type BlockMetadata struct {
	Nonce      int64   `json:"nonce,omitempty"`
	MerkleRoot string  `json:"merkleroot,omitempty"`
	Version    int32   `json:"version,omitempty"`
	Size       int64   `json:"size,omitempty"`
	Weight     int64   `json:"weight,omitempty"`
	MedianTime int64   `json:"mediantime,omitempty"`
	Bits       string  `json:"bits,omitempty"`
	Difficulty float64 `json:"difficulty,omitempty"`
}

// Transaction is a raw lbry transaction.
type Transaction struct {
	Hex      string `json:"hex"`
	Hash     string `json:"txid"`
	Size     int64  `json:"size"`
	Vsize    int64  `json:"vsize"`
	Version  int32  `json:"version"`
	Locktime int64  `json:"locktime"`
	Weight   int64  `json:"weight"`

	Inputs  []*Input  `json:"vin"`
	Outputs []*Output `json:"vout"`
}

// Metadata returns the metadata for a transaction.
func (t Transaction) Metadata() (map[string]interface{}, error) {
	m := &TransactionMetadata{
		Size:     t.Size,
		Vsize:    t.Vsize,
		Version:  t.Version,
		Locktime: t.Locktime,
		Weight:   t.Weight,
	}

	return types.MarshalMap(m)
}

// TransactionMetadata is a collection of useful
// metadata in a transaction.
type TransactionMetadata struct {
	Size     int64 `json:"size,omitempty"`
	Vsize    int64 `json:"vsize,omitempty"`
	Version  int32 `json:"version,omitempty"`
	Locktime int64 `json:"locktime,omitempty"`
	Weight   int64 `json:"weight,omitempty"`
}

// Input is a raw input in a lbry transaction.
type Input struct {
	TxHash      string     `json:"txid"`
	Vout        int64      `json:"vout"`
	ScriptSig   *ScriptSig `json:"scriptSig"`
	Sequence    int64      `json:"sequence"`
	TxInWitness []string   `json:"txinwitness"`

	// Relevant when the input is the coinbase input
	Coinbase string `json:"coinbase"`
}

// Metadata returns the metadata for an input.
func (i Input) Metadata() (map[string]interface{}, error) {
	m := &OperationMetadata{
		ScriptSig:   i.ScriptSig,
		Sequence:    i.Sequence,
		TxInWitness: i.TxInWitness,
		Coinbase:    i.Coinbase,
	}

	return types.MarshalMap(m)
}

// Output is a raw output in a lbry transaction.
type Output struct {
	Value        float64       `json:"value"`
	Index        int64         `json:"n"`
	ScriptPubKey *ScriptPubKey `json:"scriptPubKey"`
}

// Metadata returns the metadata for an output.
func (o Output) Metadata() (map[string]interface{}, error) {
	m := &OperationMetadata{
		ScriptPubKey: o.ScriptPubKey,
	}

	return types.MarshalMap(m)
}

// OperationMetadata is a collection of useful
// metadata from lbry inputs and outputs.
type OperationMetadata struct {
	// Coinbase Metadata
	Coinbase string `json:"coinbase,omitempty"`

	// Input Metadata
	ScriptSig   *ScriptSig `json:"scriptsig,omitempty"`
	Sequence    int64      `json:"sequence,omitempty"`
	TxInWitness []string   `json:"txinwitness,omitempty"`

	// Output Metadata
	ScriptPubKey *ScriptPubKey `json:"scriptPubKey,omitempty"`
}

// request represents the JSON-RPC request body
type request struct {
	JSONRPC string        `json:"jsonrpc"`
	ID      int           `json:"id"`
	Method  string        `json:"method"`
	Params  []interface{} `json:"params"`
}

func (r request) GetVersion() string       { return r.JSONRPC }
func (r request) GetID() int               { return r.ID }
func (r request) GetMethod() string        { return r.Method }
func (r request) GetParams() []interface{} { return r.Params }

// Responses

// jSONRPCResponse represents an interface for generic JSON-RPC responses
type jSONRPCResponse interface {
	Err() error
}

type responseError struct {
	Code    int64  `json:"code"`
	Message string `json:"message"`
}

// BlockResponse is the response body for `getblock` requests
type blockResponse struct {
	Result *Block         `json:"result"`
	Error  *responseError `json:"error"`
}

func (b blockResponse) Err() error {
	if b.Error == nil {
		return nil
	}

	if b.Error.Code == blockNotFoundErrCode {
		return ErrBlockNotFound
	}

	return fmt.Errorf(
		"%w: error JSON RPC response, code: %d, message: %s",
		ErrJSONRPCError,
		b.Error.Code,
		b.Error.Message,
	)
}

type pruneBlockchainResponse struct {
	Result int64          `json:"result"`
	Error  *responseError `json:"error"`
}

func (p pruneBlockchainResponse) Err() error {
	if p.Error == nil {
		return nil
	}

	return fmt.Errorf(
		"%w: error JSON RPC response, code: %d, message: %s",
		ErrJSONRPCError,
		p.Error.Code,
		p.Error.Message,
	)
}

type blockchainInfoResponse struct {
	Result *BlockchainInfo `json:"result"`
	Error  *responseError  `json:"error"`
}

func (b blockchainInfoResponse) Err() error {
	if b.Error == nil {
		return nil
	}

	return fmt.Errorf(
		"%w: error JSON RPC response, code: %d, message: %s",
		ErrJSONRPCError,
		b.Error.Code,
		b.Error.Message,
	)
}

type peerInfoResponse struct {
	Result []*PeerInfo    `json:"result"`
	Error  *responseError `json:"error"`
}

func (p peerInfoResponse) Err() error {
	if p.Error == nil {
		return nil
	}

	return fmt.Errorf(
		"%w: error JSON RPC response, code: %d, message: %s",
		ErrJSONRPCError,
		p.Error.Code,
		p.Error.Message,
	)
}

// blockHashResponse is the response body for `getblockhash` requests
type blockHashResponse struct {
	Result string         `json:"result"`
	Error  *responseError `json:"error"`
}

func (b blockHashResponse) Err() error {
	if b.Error == nil {
		return nil
	}

	return fmt.Errorf(
		"%w: error JSON RPC response, code: %d, message: %s",
		ErrJSONRPCError,
		b.Error.Code,
		b.Error.Message,
	)
}

// sendRawTransactionResponse is the response body for `sendrawtransaction` requests
type sendRawTransactionResponse struct {
	Result string         `json:"result"`
	Error  *responseError `json:"error"`
}

func (s sendRawTransactionResponse) Err() error {
	if s.Error == nil {
		return nil
	}

	return fmt.Errorf(
		"%w: error JSON RPC response, code: %d, message: %s",
		ErrJSONRPCError,
		s.Error.Code,
		s.Error.Message,
	)
}

type suggestedFeeRate struct {
	FeeRate float64 `json:"feerate"`
}

// suggestedFeeRateResponse is the response body for `estimatesmartfee` requests
type suggestedFeeRateResponse struct {
	Result *suggestedFeeRate `json:"result"`
	Error  *responseError    `json:"error"`
}

func (s suggestedFeeRateResponse) Err() error {
	if s.Error == nil {
		return nil
	}

	return fmt.Errorf(
		"%w: error JSON RPC response, code: %d, message: %s",
		ErrJSONRPCError,
		s.Error.Code,
		s.Error.Message,
	)
}

// rawMempoolResponse is the response body for `getrawmempool` requests.
type rawMempoolResponse struct {
	Result []string       `json:"result"`
	Error  *responseError `json:"error"`
}

func (r rawMempoolResponse) Err() error {
	if r.Error == nil {
		return nil
	}

	return fmt.Errorf(
		"%w: error JSON RPC response, code: %d, message: %s",
		ErrJSONRPCError,
		r.Error.Code,
		r.Error.Message,
	)
}

// CoinIdentifier converts a tx hash and vout into
// the canonical CoinIdentifier.Identifier used in
// rosetta-lbry.
func CoinIdentifier(hash string, vout int64) string {
	return fmt.Sprintf("%s:%d", hash, vout)
}

// TransactionHash extracts the transaction hash
// from a CoinIdentifier.Identifier.
func TransactionHash(identifier string) string {
	vals := strings.Split(identifier, ":")
	return vals[0]
}