package handler

import (
	"time"

	"ripple/helpers"
	"ripple/services"
	"ripple/state"
	"ripple/transport"
)

type CounterpartHandlers struct {
	st     *state.State
	pm     *services.PaymentManager
	sender *transport.AccountTransport
}

func NewCounterpartHandlers(
	st     *state.State,
	pm     *services.PaymentManager,
	sender *transport.AccountTransport,
) *CounterpartHandlers {
	return &CounterpartHandlers{
		st:     st,
		pm:     pm,
		sender: sender,
	}
}

func (h *CounterpartHandlers) FindPath(args []byte) {
	h.pm.ForwardFindPath(h.st.Memory.GetPaymentID())
}

func (h *CounterpartHandlers) CommitPayment(args []byte) {
	paymentID := h.st.Memory.GetPaymentID()
	pf, ok := h.st.Memory.GetPathfinding(paymentID)
	if !ok || pf.Counterpart.IsEmpty() || pf.InOrOut || !pf.Commit {
		return
	}
	
	h.st.Storage.MustSetPending(pf.Outgoing, paymentID)

	h.st.Storage.Payments[paymentID] = state.Payment{
		Amount:      pf.Amount,
		Outgoing:    pf.Outgoing,
		Counterpart: pf.Counterpart,
		PenaltyRate: pf.PenaltyRate,
		FeeOut:      pf.FeeOut(),
		Preimage:    h.st.Memory.Preimage,
		CreatedAt:   time.Now().Unix(),
	}

	h.st.MustSave()
	h.st.Memory.RemovePathfinding(paymentID)
	h.sender.Send(pf.Outgoing, helpers.BuildCommitPayment(paymentID))
}

func (h *CounterpartHandlers) SealPayment(args []byte) {
	paymentID := h.st.Memory.GetPaymentID()
	payment, ok := h.st.Storage.Payments[paymentID]
	if !ok || !payment.Committing() || !payment.Incoming.IsEmpty() {
		return
	}
	penaltyTicker := payment.PenaltyTicker()
	payment.CommitPenalty = penaltyTicker

	if penaltyTicker >= payment.Amount {
		payment.Cleanup()
		h.st.Storage.Payments[paymentID] = payment
		h.st.MustSave()
		h.sender.Send(payment.Outgoing, helpers.BuildCleanupPayment(paymentID))
		return
	}

	payment.Seal()
	h.st.Storage.Payments[paymentID] = payment
	h.st.MustSave()
	h.sender.Send(payment.Outgoing, helpers.BuildSealPayment(paymentID))
}