application

type AdminService interface {
	Wallet() ports.WalletService
	GetScheduledSweeps(ctx context.Context) ([]ScheduledSweep, error)
	GetRoundDetails(ctx context.Context, roundId string) (*RoundDetails, error)
	GetRounds(ctx context.Context, after int64, before int64) ([]string, error)
	GetWalletAddress(ctx context.Context) (string, error)
	GetWalletStatus(ctx context.Context) (*WalletStatus, error)
	CreateNotes(ctx context.Context, amount uint32, quantity int) ([]string, error)
	GetMarketHourConfig(ctx context.Context) (*domain.MarketHour, error)
	UpdateMarketHourConfig(
		ctx context.Context,
		marketHourStartTime, marketHourEndTime time.Time, period, roundInterval time.Duration,
	) error
	ListIntents(ctx context.Context, intentIds ...string) ([]IntentInfo, error)
	DeleteIntents(ctx context.Context, intentIds ...string) error
}

type ArkProviderBalance struct {
	MainAccountBalance       Balance
	ConnectorsAccountBalance Balance
}

type Balance struct {
	Locked    uint64
	Available uint64
}

type Batch struct {
	TotalOutputAmount uint64
	TotalOutputVtxos  int32
	ExpiresAt         int64
	Swept             bool
}

type BatchStarted struct {
	domain.RoundEvent
	IntentIdsHashes [][32]byte
	BatchExpiry     uint32
}

type ChainTx struct {
	Txid      string
	ExpiresAt int64
	Type      ChainTxType
	Spends    []string
}

type ChainTxType string

type CommitmentTxInfo struct {
	StartedAt         int64
	EndAt             int64
	Batches           map[VOut]Batch
	TotalInputAmount  uint64
	TotalInputtVtxos  int32
	TotalOutputAmount uint64
	TotalOutputVtxos  int32
}

type ForfeitTxsResp struct {
	Txs  []string
	Page PageResp
}

type GetVtxosResp struct {
	Vtxos []domain.Vtxo
	Page  PageResp
}

type IndexerService interface {
	GetCommitmentTxInfo(ctx context.Context, txid string) (*CommitmentTxInfo, error)
	GetVtxoTree(ctx context.Context, batchOutpoint Outpoint, page *Page) (*TreeTxResp, error)
	GetVtxoTreeLeaves(
		ctx context.Context, batchOutpoint Outpoint, page *Page,
	) (*VtxoTreeLeavesResp, error)
	GetForfeitTxs(ctx context.Context, txid string, page *Page) (*ForfeitTxsResp, error)
	GetConnectors(ctx context.Context, txid string, page *Page) (*TreeTxResp, error)
	GetVtxos(
		ctx context.Context,
		pubkeys []string, spendableOnly, spendOnly, recoverableOnly bool, page *Page,
	) (*GetVtxosResp, error)
	GetVtxosByOutpoint(
		ctx context.Context, outpoints []Outpoint, page *Page,
	) (*GetVtxosResp, error)
	GetVtxoChain(ctx context.Context, vtxoKey Outpoint, page *Page) (*VtxoChainResp, error)
	GetVirtualTxs(ctx context.Context, txids []string, page *Page) (*VirtualTxsResp, error)
	GetBatchSweepTxs(ctx context.Context, batchOutpoint Outpoint) ([]string, error)
}

type IntentInfo struct {
	Id             string
	CreatedAt      time.Time
	Receivers      []Receiver
	Inputs         []domain.Vtxo
	BoardingInputs []ports.BoardingInput
	Cosigners      []string
	Proof          string
	Message        string
}

type NextMarketHour struct {
	StartTime     time.Time
	EndTime       time.Time
	Period        time.Duration
	RoundInterval time.Duration
}

type OpMetric struct {
	Latency            float64 // seconds
	CPU                float64 // seconds
	CoreEq             float64
	UtilizedPct        float64
	MemAllocDelta      float64 // MB
	MemSysDelta        float64 // MB
	MemTotalAllocDelta float64 // MB
	GCDelta            uint32
}

type Outpoint = domain.Outpoint

type Page struct {
	PageSize int32
	PageNum  int32
}

type PageResp struct {
	Current int32
	Next    int32
	Total   int32
}

type Receiver struct {
	VtxoScript     string
	OnchainAddress string
	Amount         uint64
}

type RoundDetails struct {
	RoundId          string
	TxId             string
	ForfeitedAmount  uint64
	TotalVtxosAmount uint64
	TotalExitAmount  uint64
	FeesAmount       uint64
	InputVtxos       []string
	OutputVtxos      []string
	ExitAddresses    []string
	StartedAt        int64
	EndedAt          int64
}

type RoundFinalized struct {
	domain.RoundFinalized
	Txid string
}

type RoundMetrics struct {
	Latency            float64 // seconds
	CPU                float64 // seconds
	CoreEq             float64 // equivalent CPU cores used (CPU time / wall-clock time)
	UtilizedPct        float64 // CPU utilization percentage across all logical cores
	MemAllocDelta      float64 // MB
	MemSysDelta        float64 // MB
	MemTotalAllocDelta float64 // MB
	GCDelta            uint32
}

type RoundReport struct {
	RoundID string                 `json:"round_id"`
	Stats   RoundStats             `json:"round_stats"`
	Metrics RoundMetrics           `json:"round_metrics"`
	Stages  map[string]StageMetric `json:"stages"`
	Ops     map[string]OpMetric    `json:"ops"`
}

type RoundReportService interface {
	RoundStarted(roundID string)
	SetIntentsNum(numIntents int)
	RoundEnded(commitmentTxID string, totalInputs int, totalOutputs int, numTreeNodes int)
	StageStarted(stage string)
	StageEnded(stage string)
	OpStarted(op string)
	OpEnded(op string)
	Report() <-chan *RoundReport
	Close()
}

type RoundSigningStarted struct {
	domain.RoundEvent
	UnsignedCommitmentTx string
	CosignersPubkeys     []string
}

type RoundStats struct {
	NumIntents       int    `json:"num_intents"`
	TotalInputVtxos  int    `json:"total_input_vtxos"`
	TotalOutputVtxos int    `json:"total_output_vtxos"`
	NumTreeNodes     int    `json:"num_tree_nodes"`
	CommitmentTxID   string `json:"commitment_txid"`
}

type ScheduledSweep struct {
	RoundId          string
	SweepableOutputs []SweepableOutput
}

type Service interface {
	Start() error
	Stop()
	RegisterIntent(
		ctx context.Context, proof bip322.Signature, message bip322.IntentMessage,
	) (string, error)
	ConfirmRegistration(ctx context.Context, intentId string) error
	SubmitForfeitTxs(ctx context.Context, forfeitTxs []string) error
	SignCommitmentTx(ctx context.Context, commitmentTx string) error
	GetEventsChannel(ctx context.Context) <-chan []domain.Event
	GetInfo(ctx context.Context) (*ServiceInfo, error)
	SubmitOffchainTx(
		ctx context.Context, checkpointTxs []string, signedArkTx string,
	) (signedCheckpoints []string, finalArkTx string, arkTxid string, err error)
	FinalizeOffchainTx(ctx context.Context, txid string, finalCheckpoints []string) error
	// Tree signing methods
	RegisterCosignerNonces(
		ctx context.Context, roundId, pubkey string, nonces tree.TreeNonces,
	) error
	RegisterCosignerSignatures(
		ctx context.Context, roundId, pubkey string, signatures tree.TreePartialSigs,
	) error
	GetTxEventsChannel(ctx context.Context) <-chan TransactionEvent
	DeleteIntentsByProof(
		ctx context.Context, bip322signature bip322.Signature, message bip322.DeleteIntentMessage,
	) error

	// TODO: remove when detaching the indexer svc.
	GetIndexerTxChannel(ctx context.Context) <-chan TransactionEvent
}

type ServiceInfo struct {
	SignerPubKey        string
	VtxoTreeExpiry      int64
	UnilateralExitDelay int64
	BoardingExitDelay   int64
	RoundInterval       int64
	Network             string
	Dust                uint64
	ForfeitAddress      string
	NextMarketHour      *NextMarketHour
	UtxoMinAmount       int64
	UtxoMaxAmount       int64
	VtxoMinAmount       int64
	VtxoMaxAmount       int64
}

type StageMetric struct{ Latency float64 } // seconds

type SweepableOutput struct {
	TxId        string
	Vout        uint32
	Amount      uint64
	ScheduledAt int64
}

type TransactionEvent struct {
	TxData
	Type           TransactionEventType
	SpentVtxos     []domain.Vtxo
	SpendableVtxos []domain.Vtxo
	CheckpointTxs  map[string]TxData
}

type TransactionEventType string

type TreeNoncesAggregated struct {
	domain.RoundEvent
	Nonces tree.TreeNonces // aggregated nonces
}

type TreeSignatureMessage struct {
	domain.RoundEvent
	Topic      []string
	BatchIndex int32
	Txid       string
	Signature  string
}

type TreeTx = tree.TxTreeNode

type TreeTxMessage struct {
	domain.RoundEvent
	Topic      []string
	BatchIndex int32
	Node       tree.TxTreeNode
}

type TreeTxResp struct {
	Txs  []TreeTx
	Page PageResp
}

type TxData struct {
	Tx   string
	Txid string
}

type TxType int

type VOut int

type VirtualTxsResp struct {
	Txs  []string
	Page PageResp
}

type VtxoChainResp struct {
	Chain []ChainTx
	Page  PageResp
}

type VtxoTreeLeavesResp struct {
	Leaves []domain.Vtxo
	Page   PageResp
}

type WalletStatus struct {
	IsInitialized bool
	IsUnlocked    bool
	IsSynced      bool
}