package sealing

import (
	"github.com/ipfs/go-cid"

	"github.com/filecoin-project/lotus/api"
)

type mutator interface {
	apply(state *SectorInfo)
}

// globalMutator is an event which can apply in every state
type globalMutator interface {
	// applyGlobal applies the event to the state. If if returns true,
	//  event processing should be interrupted
	applyGlobal(state *SectorInfo) bool
}

// Global events

type SectorRestart struct{}

func (evt SectorRestart) applyGlobal(*SectorInfo) bool { return false }

type SectorFatalError struct{ error }

func (evt SectorFatalError) applyGlobal(state *SectorInfo) bool {
	log.Errorf("Fatal error on sector %d: %+v", state.SectorID, evt.error)
	// TODO: Do we want to mark the state as unrecoverable?
	//  I feel like this should be a softer error, where the user would
	//  be able to send a retry event of some kind
	return true
}

type SectorForceState struct {
	state api.SectorState
}

func (evt SectorForceState) applyGlobal(state *SectorInfo) bool {
	state.State = evt.state
	return true
}

// Normal path

type SectorStart struct {
	id     uint64
	pieces []Piece
}

func (evt SectorStart) apply(state *SectorInfo) {
	state.SectorID = evt.id
	state.Pieces = evt.pieces
}

type SectorPacked struct{ pieces []Piece }

func (evt SectorPacked) apply(state *SectorInfo) {
	state.Pieces = append(state.Pieces, evt.pieces...)
}

type SectorPackingFailed struct{ error }

func (evt SectorPackingFailed) apply(*SectorInfo) {}

type SectorSealed struct {
	commR  []byte
	commD  []byte
	ticket SealTicket
}

func (evt SectorSealed) apply(state *SectorInfo) {
	state.CommD = evt.commD
	state.CommR = evt.commR
	state.Ticket = evt.ticket
}

type SectorSealFailed struct{ error }

func (evt SectorSealFailed) apply(*SectorInfo) {}

type SectorPreCommitFailed struct{ error }

func (evt SectorPreCommitFailed) apply(*SectorInfo) {}

type SectorPreCommitted struct {
	message cid.Cid
}

func (evt SectorPreCommitted) apply(state *SectorInfo) {
	state.PreCommitMessage = &evt.message
}

type SectorSeedReady struct {
	seed SealSeed
}

func (evt SectorSeedReady) apply(state *SectorInfo) {
	state.Seed = evt.seed
}

type SectorComputeProofFailed struct{ error }

type SectorCommitFailed struct{ error }

func (evt SectorCommitFailed) apply(*SectorInfo) {}

type SectorCommitted struct {
	message cid.Cid
	proof   []byte
}

func (evt SectorCommitted) apply(state *SectorInfo) {
	state.Proof = evt.proof
	state.CommitMessage = &evt.message
}

type SectorProving struct{}

func (evt SectorProving) apply(*SectorInfo) {}

type SectorFinalized struct{}

func (evt SectorFinalized) apply(*SectorInfo) {}

type SectorFinalizeFailed struct{ error }

func (evt SectorFinalizeFailed) apply(*SectorInfo) {}

// Failed state recovery

type SectorRetrySeal struct{}

func (evt SectorRetrySeal) apply(state *SectorInfo) {}

type SectorRetryPreCommit struct{}

func (evt SectorRetryPreCommit) apply(state *SectorInfo) {}

type SectorRetryWaitSeed struct{}

func (evt SectorRetryWaitSeed) apply(state *SectorInfo) {}

// Faults

type SectorFaulty struct{}

func (evt SectorFaulty) apply(state *SectorInfo) {}

type SectorFaultReported struct{ reportMsg cid.Cid }

func (evt SectorFaultReported) apply(state *SectorInfo) {
	state.FaultReportMsg = &evt.reportMsg
}

type SectorFaultedFinal struct{}