package state

import (
	"time"
	"ripple/bug"
	"ripple/config"
	"ripple/errmsgs"
	"ripple/types"
)

const (
	Commit   = 0
	Sealed   = 1
	Cancel   = 2
)

type User struct {
	SecretKey [32]byte
	TrustIndex float32
}

type Payment struct {
	Amount      uint64
	FeeIn       uint64
	FeeOut      uint64
	Tax         uint64
	Incoming    types.UserIdentifier
	Outgoing    types.UserIdentifier
	Counterpart types.UserIdentifier
	Preimage    [32]byte
	Status      byte
	Timeout     int64
}

type Sync struct {
	TurnBit       byte
	TurnCounter   uint32
	LastValidated types.Instruction
}

type Account struct {
	Creditline   int64
	Width        float32
	Pending      map[[32]byte]struct{}
	TrustlineIn  uint64
	TrustlineOut uint64
	Sync
}

type Receipt struct {
	Identifier  [32]byte
	Counterpart types.UserIdentifier
	Amount      int64
	Timestamp   int64
}

type Storage struct {
	User     User
	Accounts map[types.UserIdentifier]Account
	Payments map[[32]byte]Payment
	Preimage [32]byte
	Receipts [config.BufferSize]Receipt
}

func (s *Storage) MustGetAccount(id types.UserIdentifier) Account {
	acc, ok := s.Accounts[id]
	if !ok {
		panic(bug.BugStateViolated)
	}
	return acc
}

func (s *Storage) AccountExists(id types.UserIdentifier) bool {
	_, ok := s.Accounts[id]
	return ok
}

func (s *Storage) AddAccount(id types.UserIdentifier, turnBit byte) error {
	if s.AccountExists(id) {
		panic(bug.BugStateViolated)
	}
	if len(s.Accounts) >= config.BufferSize {
		return errmsgs.ErrBufferFull
	}
	s.Accounts[id] = Account{
		Sync: Sync{
			TurnBit: turnBit,
		},
		Pending: make(map[[32]byte]struct{}),
	}
	return nil
}

func (s *Storage) RemoveAccount(id types.UserIdentifier) {
	if !s.AccountExists(id) {
		panic(bug.BugStateViolated)
	}
    delete(s.Accounts, id)
}

func (s *Storage) MustGetPayment(paymentID [32]byte) Payment {
	payment, ok := s.Payments[paymentID]
	if !ok {
		panic(bug.BugStateViolated)
	}
	return payment
}

func (s *Storage) GetBandwidthOut(id types.UserIdentifier) int64 {
    acc := s.MustGetAccount(id)
    bandwidthOut := int64(acc.TrustlineIn) + acc.Creditline
    for paymentID := range acc.Pending {
        payment := s.MustGetPayment(paymentID)
        if payment.Outgoing == id {
            bandwidthOut -= int64(payment.Amount-payment.FeeOut+payment.Tax)
        }
    }
    return bandwidthOut
}

func (s *Storage) GetBandwidthIn(id types.UserIdentifier) int64 {
    acc := s.MustGetAccount(id)
    bandwidthIn := int64(acc.TrustlineOut) - acc.Creditline
    for paymentID := range acc.Pending {
        payment := s.MustGetPayment(paymentID)
        if payment.Incoming == id {
            bandwidthIn -= int64(payment.Amount-payment.FeeIn+payment.Tax)
        }
    }
    return bandwidthIn
}

func (s *Storage) AddReceipt(r Receipt) {
    copy(s.Receipts[1:], s.Receipts[:])
    s.Receipts[0] = r
}

func (p *Payment) Committed() bool {
	return p.Status == Commit
}

func (p *Payment) Cancelled() bool {
	return p.Status == Cancel
}

func (p *Payment) Sealed() bool {
	return p.Status == Sealed
}

func (p *Payment) CalculateFee() uint64 {
	fee := (time.Now().Unix() - p.Timeout) / int64(config.FeeRate/time.Second)
	if fee < 0 {
		return 0
	}
	return uint64(fee)
}

func (p *Payment) GetTaxRate() float32 {
	return float32(p.Tax)/float32(p.Amount)
}

func (a *Account) IncreaseCreditline(amount int64, taxrate float32) {
    newCreditLine := a.Creditline + amount
    if newCreditLine > 0 {
        var weight float32
        if a.Creditline > 0 {
            weight = float32(a.Creditline) / float32(newCreditLine)
        }
        a.Width = weight*a.Width + (1 - weight)*taxrate
    }
    a.Creditline = newCreditLine
}

func (a *Account) DecreaseCreditline(amount int64, taxrate float32) {
    newCreditLine := a.Creditline - amount
    if newCreditLine < 0 {
        var weight float32
        if a.Creditline < 0 {
            weight = float32(-a.Creditline) / float32(-newCreditLine)
        }
        a.Width = weight*a.Width + (1 - weight)*taxrate
    }
    a.Creditline = newCreditLine
}