operations

var CreateAddressRefOp = cldfops.NewOperation(
	"catalog-create-address-ref",
	semver.MustParse("1.0.0"),
	"Add address ref entries to the Catalog service",
	func(b cldfops.Bundle, deps CreateAddressRefDeps, input CreateAddressRefInput) (CreateAddressRefOutput, error) {
		dataStore := cldfdatastore.NewMemoryDataStore()
		err := dataStore.Merge(deps.DataStore)
		if err != nil {
			return CreateAddressRefOutput{}, fmt.Errorf("failed to create memory data store: %w", err)
		}

		for i, item := range input.AddressRefs {
			err = dataStore.Addresses().Add(item)
			if err != nil {
				return CreateAddressRefOutput{}, fmt.Errorf("failed to create address ref entry %d in catalog store: %w", i, err)
			}
		}

		b.Logger.Infow("Catalog AddressRef created successfully")

		return CreateAddressRefOutput{DataStore: dataStore}, nil
	},
)

var CreateChainMetadataOp = cldfops.NewOperation(
	"catalog-create-chain-metadata",
	semver.MustParse("1.0.0"),
	"Add chain metadata entries to the Catalog service",
	func(b cldfops.Bundle, deps CreateChainMetadataDeps, input CreateChainMetadataInput) (CreateChainMetadataOutput, error) {
		dataStore := cldfdatastore.NewMemoryDataStore()
		err := dataStore.Merge(deps.DataStore)
		if err != nil {
			return CreateChainMetadataOutput{}, fmt.Errorf("failed to create memory data store: %w", err)
		}

		for i, item := range input.ChainMetadata {
			err = dataStore.ChainMetadata().Add(item)
			if err != nil {
				return CreateChainMetadataOutput{}, fmt.Errorf("failed to create chain metadata entry %d in catalog store: %w", i, err)
			}
		}

		b.Logger.Infow("Catalog ChainMetadata created successfully")

		return CreateChainMetadataOutput{DataStore: dataStore}, nil
	},
)

var CreateContractMetadataOp = cldfops.NewOperation(
	"catalog-create-contract-metadata",
	semver.MustParse("1.0.0"),
	"Add contract metadata entries to the Catalog service",
	func(b cldfops.Bundle, deps CreateContractMetadataDeps, input CreateContractMetadataInput) (CreateContractMetadataOutput, error) {
		dataStore := cldfdatastore.NewMemoryDataStore()
		err := dataStore.Merge(deps.DataStore)
		if err != nil {
			return CreateContractMetadataOutput{}, fmt.Errorf("failed to create memory data store: %w", err)
		}

		for i, item := range input.ContractMetadata {
			err = dataStore.ContractMetadata().Add(item)
			if err != nil {
				return CreateContractMetadataOutput{}, fmt.Errorf("failed to create contract metadata entry %d in catalog store: %w", i, err)
			}
		}

		b.Logger.Infow("Catalog ContractMetadata created successfully")

		return CreateContractMetadataOutput{DataStore: dataStore}, nil
	},
)

var UpdateAddressRefOp = cldfops.NewOperation(
	"catalog-update-address-ref",
	semver.MustParse("1.0.0"),
	"Update address ref entries in the Catalog service",
	func(b cldfops.Bundle, deps UpdateAddressRefDeps, input UpdateAddressRefInput) (UpdateAddressRefOutput, error) {
		dataStore := cldfdatastore.NewMemoryDataStore()
		err := dataStore.Merge(deps.DataStore)
		if err != nil {
			return UpdateAddressRefOutput{}, fmt.Errorf("failed to create memory data store: %w", err)
		}

		for i, item := range input.AddressRefs {
			err = dataStore.Addresses().Update(item)
			if err != nil {
				return UpdateAddressRefOutput{}, fmt.Errorf("failed to update address ref entry %d in catalog store: %w", i, err)
			}
		}

		b.Logger.Infow("Catalog AddressRef updated successfully")

		return UpdateAddressRefOutput{DataStore: dataStore}, nil
	},
)

var UpdateChainMetadataOp = cldfops.NewOperation(
	"catalog-update-chain-metadata",
	semver.MustParse("1.0.0"),
	"Update chain metadata entries in the Catalog service",
	func(b cldfops.Bundle, deps UpdateChainMetadataDeps, input UpdateChainMetadataInput) (UpdateChainMetadataOutput, error) {
		dataStore := cldfdatastore.NewMemoryDataStore()
		err := dataStore.Merge(deps.DataStore)
		if err != nil {
			return UpdateChainMetadataOutput{}, fmt.Errorf("failed to create memory data store: %w", err)
		}

		for i, item := range input.ChainMetadata {
			err = dataStore.ChainMetadata().Update(item)
			if err != nil {
				return UpdateChainMetadataOutput{}, fmt.Errorf("failed to update chain metadata entry %d in catalog store: %w", i, err)
			}
		}

		b.Logger.Infow("Catalog ChainMetadata updated successfully")

		return UpdateChainMetadataOutput{DataStore: dataStore}, nil
	},
)

var UpdateContractMetadataOp = cldfops.NewOperation(
	"catalog-update-contract-metadata",
	semver.MustParse("1.0.0"),
	"Update contract metadata entries in the Catalog service",
	func(b cldfops.Bundle, deps UpdateContractMetadataDeps, input UpdateContractMetadataInput) (UpdateContractMetadataOutput, error) {
		dataStore := cldfdatastore.NewMemoryDataStore()
		err := dataStore.Merge(deps.DataStore)
		if err != nil {
			return UpdateContractMetadataOutput{}, fmt.Errorf("failed to create memory data store: %w", err)
		}

		for i, item := range input.ContractMetadata {
			err = dataStore.ContractMetadata().Update(item)
			if err != nil {
				return UpdateContractMetadataOutput{}, fmt.Errorf("failed to update contract metadata entry %d in catalog store: %w", i, err)
			}
		}

		b.Logger.Infow("Catalog ContractMetadata updated successfully")

		return UpdateContractMetadataOutput{DataStore: dataStore}, nil
	},
)

var UpdateEnvMetadataOp = cldfops.NewOperation(
	"catalog-update-env-metadata",
	semver.MustParse("1.0.0"),
	"Update env metadata entries in the Catalog service",
	func(b cldfops.Bundle, deps UpdateEnvMetadataDeps, input UpdateEnvMetadataInput) (UpdateEnvMetadataOutput, error) {
		dataStore := cldfdatastore.NewMemoryDataStore()
		err := dataStore.Merge(deps.DataStore)
		if err != nil {
			return UpdateEnvMetadataOutput{}, fmt.Errorf("failed to create memory data store: %w", err)
		}

		err = dataStore.EnvMetadata().Set(input.EnvMetadata)
		if err != nil {
			return UpdateEnvMetadataOutput{}, fmt.Errorf("failed to update env metadata in catalog store: %w", err)
		}

		b.Logger.Infow("Catalog EnvMetadata updated successfully")

		return UpdateEnvMetadataOutput{DataStore: dataStore}, nil
	},
)