ton

var AnySequence = operations.NewSequence(
	"ton/sequences/any",
	semver.MustParse("0.1.0"),
	"Executes and/or plans a sequence of operations as defined by the inputs",
	anySeqHandler,
)

var Deploy = operations.NewOperation(
	"ton/ops/deploy",
	semver.MustParse("0.2.0"),
	"Deploys contracts by sending messages with code loaded from the provider",
	func(b operations.Bundle, dp *dep.DependencyProvider, in DeployInput) (DeployOutput, error) {

		_messages := make([]InternalMessage[any], len(in.Messages))
		for i, u := range in.Messages {
			contractProvider, err := dep.Resolve[ContractCodeProvider](dp)
			if err != nil {
				return DeployOutput{}, fmt.Errorf("failed to resolve contract provider: %w", err)
			}

			c, err := contractProvider.GetContract(u.ContractMeta)
			if err != nil {
				return DeployOutput{}, fmt.Errorf("failed to get contract code: %w", err)
			}

			var data *cell.Cell
			if u.Data != nil {

				data, err = encodeDataCellFor(u.Data)
				if err != nil {
					return DeployOutput{}, fmt.Errorf("failed to encode data cell: %w", err)
				}
			}

			m := u.Message
			_messages[i] = InternalMessage[any]{
				Bounce:  m.Bounce,
				DstAddr: m.DstAddr,
				Amount:  m.Amount,
				Body:    m.Body,
				StateInit: &StateInit{
					Code: c.Code,
					Data: data,
				},
			}
		}

		_in := SendMessagesInput{
			Messages: _messages,
			Plan:     in.Plan,
		}

		r, err := operations.ExecuteOperation(b, SendMessages, dp, _in)
		if err != nil {
			return DeployOutput{}, fmt.Errorf("failed to exec send messages operation: %w", err)
		}

		return DeployOutput(r.Output), nil
	},
)

var SendMessages = cldf_ops.NewOperation(
	"ton/ops/send-messages",
	semver.MustParse("0.1.0"),
	"Sends and/or plans messages as defined by the inputs",
	func(b cldf_ops.Bundle, dp *dep.DependencyProvider, in SendMessagesInput) (SendMessagesOutput, error) {
		msgs := make([]*tlbe.Cell[tlb.InternalMessage], 0, len(in.Messages))
		plans := make([]MessagePlanRaw, 0, len(in.Messages))

		for _, m := range in.Messages {
			_im, err := m.ToMessage()
			if err != nil {
				return SendMessagesOutput{}, fmt.Errorf("failed to convert internal message to message: %w", err)
			}

			opcode, err := tvm.ExtractOpcode(_im.Body)
			if err != nil {
				return SendMessagesOutput{}, fmt.Errorf("failed to extract opcode from message body: %w", err)
			}

			if _im.DstAddr == nil || _im.DstAddr.IsAddrNone() || _im.DstAddr.Equals(tvm.ZeroAddress) {
				return SendMessagesOutput{}, fmt.Errorf("internal message (%x) destination cannot be nil or zero address", opcode)
			}

			if _im.Body == nil || tvm.CellEquals(_im.Body, tvm.EmptyCell) {
				if !m.Bounce {
					return SendMessagesOutput{}, errors.New("empty body messages must have bounce enabled")
				}
			}

			_imc, err := tlbe.NewCellFrom(*_im)
			if err != nil {
				return SendMessagesOutput{}, fmt.Errorf("failed to convert internal message to cell: %w", err)
			}

			plan := MessagePlanRaw{
				Opcode:  opcode,
				DstAddr: _im.DstAddr,
				Amount:  m.Amount,

				Cell: _imc,
			}
			plans = append(plans, plan)
			msgs = append(msgs, _imc)
		}

		if in.Plan {
			return SendMessagesOutput{Plans: plans}, nil
		}

		out, err := cldf_ops.ExecuteOperation(b, SendMessagesRaw, dp, SendMessagesRawInput{Messages: msgs})
		if err != nil {
			return SendMessagesOutput{}, fmt.Errorf("failed to send messages: %w", err)
		}

		return out.Output, nil
	},
)

var SendMessagesRaw = cldf_ops.NewOperation(
	"ton/ops/send-messages-raw",
	semver.MustParse("0.1.0"),
	"Sends (raw) messages as defined by the inputs",
	func(b cldf_ops.Bundle, dp *dep.DependencyProvider, in SendMessagesRawInput) (SendMessagesOutput, error) {
		ctx := b.GetContext()

		n := len(in.Messages)
		msgs := make([]*wallet.Message, 0, n)

		for _, m := range in.Messages {
			_im, err := m.ToValue()
			if err != nil {
				return SendMessagesOutput{}, fmt.Errorf("failed to decode internal message from cell: %w", err)
			}

			msgs = append(msgs, &wallet.Message{
				Mode:            wallet.PayGasSeparately | wallet.IgnoreErrors,
				InternalMessage: &_im,
			})
		}

		chain, err := dep.Resolve[cldf_ton.Chain](dp)
		if err != nil {
			return SendMessagesOutput{}, fmt.Errorf("failed to resolve chain: %w", err)
		}

		b.Logger.Infow("Sending messages", "msgs", msgs)

		_tx, block, err := chain.Wallet.SendManyWaitTransaction(ctx, msgs)
		if err != nil {
			return SendMessagesOutput{}, fmt.Errorf("failed to send transaction: %w", err)
		}

		b.Logger.Infow("Transaction sent", "blockID", block, "tx", _tx)

		err = tracetracking.WaitForTrace(ctx, chain.Client, _tx)
		if err != nil {
			return SendMessagesOutput{}, fmt.Errorf("failed to wait for trace: %w", err)
		}

		tx, err := tlbe.NewCellFrom(*_tx)
		if err != nil {
			return SendMessagesOutput{}, fmt.Errorf("failed to convert transaction to cell: %w", err)
		}

		return SendMessagesOutput{
			Transaction: tx,
			BlockInfo:   block,
		}, nil
	},
)