package test

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"sort"
	"strconv"

	"github.com/hermeznetwork/hermez-node/common"
)

var eof = rune(0)
var errof = fmt.Errorf("eof in parseline")
var errComment = fmt.Errorf("comment in parseline")
var errNewBatch = fmt.Errorf("newbatch")

// TypeNewBatch is used for testing purposes only, and represents the
// common.TxType of a new batch
var TypeNewBatch common.TxType = "TxTypeNewBatch"

//nolint
const (
	ILLEGAL token = iota
	WS
	EOF

	IDENT // val
)

// Instruction is the data structure that represents one line of code
type Instruction struct {
	Literal string
	From    string
	To      string
	Amount  uint64
	Fee     uint8
	TokenID common.TokenID
	Type    common.TxType // D: Deposit, T: Transfer, E: ForceExit
}

// Instructions contains the full Set of Instructions representing a full code
type Instructions struct {
	Instructions []*Instruction
	Accounts     []string
	TokenIDs     []common.TokenID
}

func (i Instruction) String() string {
	buf := bytes.NewBufferString("")
	switch i.Type {
	case common.TxTypeCreateAccountDeposit:
		fmt.Fprintf(buf, "Type: Create&Deposit, ")
	case common.TxTypeTransfer:
		fmt.Fprintf(buf, "Type: Transfer, ")
	case common.TxTypeForceExit:
		fmt.Fprintf(buf, "Type: ForceExit, ")
	default:
	}
	fmt.Fprintf(buf, "From: %s, ", i.From)
	if i.Type == common.TxTypeTransfer {
		fmt.Fprintf(buf, "To: %s, ", i.To)
	}
	fmt.Fprintf(buf, "Amount: %d, ", i.Amount)
	if i.Type == common.TxTypeTransfer {
		fmt.Fprintf(buf, "Fee: %d, ", i.Fee)
	}
	fmt.Fprintf(buf, "TokenID: %d,\n", i.TokenID)
	return buf.String()
}

// Raw returns a string with the raw representation of the Instruction
func (i Instruction) Raw() string {
	buf := bytes.NewBufferString("")
	fmt.Fprintf(buf, "%s", i.From)
	if i.Type == common.TxTypeTransfer {
		fmt.Fprintf(buf, "-%s", i.To)
	}
	fmt.Fprintf(buf, " (%d)", i.TokenID)
	if i.Type == common.TxTypeForceExit {
		fmt.Fprintf(buf, "E")
	}
	fmt.Fprintf(buf, ":")
	fmt.Fprintf(buf, " %d", i.Amount)
	if i.Type == common.TxTypeTransfer {
		fmt.Fprintf(buf, " %d", i.Fee)
	}
	return buf.String()
}

type token int

type scanner struct {
	r *bufio.Reader
}

func isWhitespace(ch rune) bool {
	return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '\v' || ch == '\f'
}

func isLetter(ch rune) bool {
	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
}

func isComment(ch rune) bool {
	return ch == '/'
}

func isDigit(ch rune) bool {
	return (ch >= '0' && ch <= '9')
}

// newScanner creates a new scanner with the given io.Reader
func newScanner(r io.Reader) *scanner {
	return &scanner{r: bufio.NewReader(r)}
}

func (s *scanner) read() rune {
	ch, _, err := s.r.ReadRune()
	if err != nil {
		return eof
	}
	return ch
}

func (s *scanner) unread() {
	_ = s.r.UnreadRune()
}

// scan returns the token and literal string of the current value
func (s *scanner) scan() (tok token, lit string) {
	ch := s.read()

	if isWhitespace(ch) {
		// space
		s.unread()
		return s.scanWhitespace()
	} else if isLetter(ch) || isDigit(ch) {
		// letter/digit
		s.unread()
		return s.scanIndent()
	} else if isComment(ch) {
		// comment
		s.unread()
		return s.scanIndent()
	}

	if ch == eof {
		return EOF, ""
	}

	return ILLEGAL, string(ch)
}

func (s *scanner) scanWhitespace() (token token, lit string) {
	var buf bytes.Buffer
	buf.WriteRune(s.read())

	for {
		if ch := s.read(); ch == eof {
			break
		} else if !isWhitespace(ch) {
			s.unread()
			break
		} else {
			_, _ = buf.WriteRune(ch)
		}
	}
	return WS, buf.String()
}

func (s *scanner) scanIndent() (tok token, lit string) {
	var buf bytes.Buffer
	buf.WriteRune(s.read())

	for {
		if ch := s.read(); ch == eof {
			break
		} else if !isLetter(ch) && !isDigit(ch) {
			s.unread()
			break
		} else {
			_, _ = buf.WriteRune(ch)
		}
	}

	if len(buf.String()) == 1 {
		return token(rune(buf.String()[0])), buf.String()
	}
	return IDENT, buf.String()
}

// Parser defines the parser
type Parser struct {
	s   *scanner
	buf struct {
		tok token
		lit string
		n   int
	}
}

// NewParser creates a new parser from a io.Reader
func NewParser(r io.Reader) *Parser {
	return &Parser{s: newScanner(r)}
}

func (p *Parser) scan() (tok token, lit string) {
	// if there is a token in the buffer return it
	if p.buf.n != 0 {
		p.buf.n = 0
		return p.buf.tok, p.buf.lit
	}
	tok, lit = p.s.scan()

	p.buf.tok, p.buf.lit = tok, lit

	return
}

func (p *Parser) scanIgnoreWhitespace() (tok token, lit string) {
	tok, lit = p.scan()
	if tok == WS {
		tok, lit = p.scan()
	}
	return
}

// parseLine parses the current line
func (p *Parser) parseLine() (*Instruction, error) {
	// line can be Deposit:
	//         A (1): 10
	// or Transfer:
	//         A-B (1): 6
	// or Withdraw:
	//         A (1) E: 4
	// or NextBatch:
	// 	> and here the comment

	c := &Instruction{}
	tok, lit := p.scanIgnoreWhitespace()
	if tok == EOF {
		return nil, errof
	}
	c.Literal += lit
	if lit == "/" {
		_, _ = p.s.r.ReadString('\n')
		return nil, errComment
	} else if lit == ">" {
		_, _ = p.s.r.ReadString('\n')
		return nil, errNewBatch
	}
	c.From = lit

	_, lit = p.scanIgnoreWhitespace()
	c.Literal += lit
	if lit == "-" {
		// transfer
		_, lit = p.scanIgnoreWhitespace()
		c.Literal += lit
		c.To = lit
		c.Type = common.TxTypeTransfer
		_, lit = p.scanIgnoreWhitespace() // expect (
		c.Literal += lit
		if lit != "(" {
			line, _ := p.s.r.ReadString('\n')
			c.Literal += line
			return c, fmt.Errorf("Expected '(', found '%s'", lit)
		}
	} else {
		c.Type = common.TxTypeCreateAccountDeposit
	}

	_, lit = p.scanIgnoreWhitespace()
	c.Literal += lit
	tidI, err := strconv.Atoi(lit)
	if err != nil {
		line, _ := p.s.r.ReadString('\n')
		c.Literal += line
		return c, err
	}
	c.TokenID = common.TokenID(tidI)
	_, lit = p.scanIgnoreWhitespace() // expect )
	c.Literal += lit
	if lit != ")" {
		line, _ := p.s.r.ReadString('\n')
		c.Literal += line
		return c, fmt.Errorf("Expected ')', found '%s'", lit)
	}

	_, lit = p.scanIgnoreWhitespace() // expect ':' or 'E' (Exit type)
	c.Literal += lit
	if lit == "E" {
		c.Type = common.TxTypeForceExit
		_, lit = p.scanIgnoreWhitespace() // expect ':'
		c.Literal += lit
	}
	if lit != ":" {
		line, _ := p.s.r.ReadString('\n')
		c.Literal += line
		return c, fmt.Errorf("Expected ':', found '%s'", lit)
	}
	tok, lit = p.scanIgnoreWhitespace()
	c.Literal += lit
	amount, err := strconv.Atoi(lit)
	if err != nil {
		line, _ := p.s.r.ReadString('\n')
		c.Literal += line
		return c, err
	}
	c.Amount = uint64(amount)

	if c.Type == common.TxTypeTransfer {
		tok, lit = p.scanIgnoreWhitespace()
		c.Literal += lit
		fee, err := strconv.Atoi(lit)
		if err != nil {
			line, _ := p.s.r.ReadString('\n')
			c.Literal += line
			return c, err
		}
		if fee > common.MaxFeePlan-1 {
			line, _ := p.s.r.ReadString('\n')
			c.Literal += line
			return c, fmt.Errorf("Fee %d can not be bigger than 255", fee)
		}
		c.Fee = uint8(fee)
	}

	if tok == EOF {
		return nil, errof
	}
	return c, nil
}

func idxTokenIDToString(idx string, tid common.TokenID) string {
	return idx + strconv.Itoa(int(tid))
}

// Parse parses through reader
func (p *Parser) Parse() (Instructions, error) {
	var instructions Instructions
	i := 0
	accounts := make(map[string]bool)
	tokenids := make(map[common.TokenID]bool)
	for {
		instruction, err := p.parseLine()
		if err == errof {
			break
		}
		if err == errComment {
			i++
			continue
		}
		if err == errNewBatch {
			i++
			inst := &Instruction{Type: TypeNewBatch}
			instructions.Instructions = append(instructions.Instructions, inst)
			continue
		}
		if err != nil {
			return instructions, fmt.Errorf("error parsing line %d: %s, err: %s", i, instruction.Literal, err.Error())
		}
		instructions.Instructions = append(instructions.Instructions, instruction)
		accounts[idxTokenIDToString(instruction.From, instruction.TokenID)] = true
		if instruction.Type == common.TxTypeTransfer { // type: Transfer
			accounts[idxTokenIDToString(instruction.To, instruction.TokenID)] = true
		}
		tokenids[instruction.TokenID] = true
		i++
	}
	for a := range accounts {
		instructions.Accounts = append(instructions.Accounts, a)
	}
	sort.Strings(instructions.Accounts)
	for tid := range tokenids {
		instructions.TokenIDs = append(instructions.TokenIDs, tid)
	}
	return instructions, nil
}