package typeddata

import (
	"encoding/json"
	"errors"
	"fmt"
	"math/big"
	"strconv"
)

const (
	eip712Domain = "EIP712Domain"
	ChainIDKey   = "chainId"
)

// Types define fields for each composite type.
type Types map[string][]Field

// Field stores name and solidity type of the field.
type Field struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

// Validate checks that both name and type are not empty.
func (f Field) Validate() error {
	if len(f.Name) == 0 {
		return errors.New("`name` is required")
	}
	if len(f.Type) == 0 {
		return errors.New("`type` is required")
	}
	return nil
}

// TypedData defines typed data according to eip-712.
type TypedData struct {
	Types       Types                      `json:"types"`
	PrimaryType string                     `json:"primaryType"`
	Domain      map[string]json.RawMessage `json:"domain"`
	Message     map[string]json.RawMessage `json:"message"`
}

// Validate that required fields are defined.
// This method doesn't check if dependencies of the main type are defined, it will be validated
// when type string is computed.
func (t TypedData) Validate() error {
	if _, exist := t.Types[eip712Domain]; !exist {
		return fmt.Errorf("`%s` must be in `types`", eip712Domain)
	}
	if t.PrimaryType == "" {
		return errors.New("`primaryType` is required")
	}
	if _, exist := t.Types[t.PrimaryType]; !exist {
		return fmt.Errorf("primary type `%s` not defined in types", t.PrimaryType)
	}
	if t.Domain == nil {
		return errors.New("`domain` is required")
	}
	if t.Message == nil {
		return errors.New("`message` is required")
	}
	for typ := range t.Types {
		fields := t.Types[typ]
		for i := range fields {
			if err := fields[i].Validate(); err != nil {
				return fmt.Errorf("field %d from type `%s` is invalid: %v", i, typ, err)
			}
		}
	}
	return nil
}

// ValidateChainID accept chain as big integer and verifies if typed data belongs to the same chain.
func (t TypedData) ValidateChainID(chain *big.Int) error {
	if _, exist := t.Domain[ChainIDKey]; !exist {
		return fmt.Errorf("domain misses chain key %s", ChainIDKey)
	}
	var chainID int64
	if err := json.Unmarshal(t.Domain[ChainIDKey], &chainID); err != nil {
		var chainIDString string
		if err = json.Unmarshal(t.Domain[ChainIDKey], &chainIDString); err != nil {
			return err
		}
		if chainID, err = strconv.ParseInt(chainIDString, 0, 64); err != nil {
			return err
		}
	}
	if chainID != chain.Int64() {
		return fmt.Errorf("chainId %d doesn't match selected chain %s", chainID, chain)
	}
	return nil
}