usecases

type ContractInput struct {
	Blockchain common.Blockchain `json:"blockchain" validate:"required,oneof=ethereum polygon arbitrum optimism"`
	Address    string            `json:"address" validate:"required,eth_addr"`
	Interface  common.Interface  `` /* 176-byte string literal not displayed */
}

type CurrencyInput struct {
	Blockchain common.Blockchain `json:"blockchain" validate:"required,oneof=ethereum polygon arbitrum optimism"`
}

type DisplayAchievementInput struct {
	Id    string                 `json:"id" validate:"required"`
	Index uint64                 `json:"index" validate:"gte=0"`
	Type  common.AchievementType `json:"type" validate:"required,oneof=interactions"`
}

type DisplayAchievementsInput struct {
	Text  string                     `json:"text" validate:"max=30"`
	Items *[]DisplayAchievementInput `json:"items" validate:"required,dive"`
}

type DisplayColorsInput struct {
	Primary       string `json:"primary" validate:"required,max=15"`
	Secondary     string `json:"secondary" validate:"required,max=15"`
	PrimaryText   string `json:"primary_text" validate:"required,max=15"`
	SecondaryText string `json:"secondary_text" validate:"required,max=15"`
	Shadow        string `json:"shadow" validate:"required,max=15"`
	Accent        string `json:"accent" validate:"required,max=15"`
}

type DisplayConfigInput struct {
	Colors       *DisplayColorsInput       `json:"colors" validate:"required,dive"`
	Info         *DisplayInfoInput         `json:"info" validate:"required,dive"`
	Achievements *DisplayAchievementsInput `json:"achievements" validate:"required,dive"`
	Groups       *[]DisplayGroupInput      `json:"groups" validate:"required,dive"`
}

type DisplayGroupInput struct {
	Id    string              `json:"id" validate:"required,max=30"`
	Text  string              `json:"text" validate:"max=30"`
	Items *[]DisplayItemInput `json:"items" validate:"required,dive"`
}

type DisplayInfoInput struct {
	Title         string `json:"title" validate:"max=40"`
	Description   string `json:"description" validate:"max=1000"`
	TwitterHandle string `json:"twitter_handle" validate:"max=15"`
}

type DisplayItemInput struct {
	Id    string           `json:"id" validate:"required"`
	Index uint64           `json:"index" validate:"gte=0"`
	Type  common.BadgeType `json:"type" validate:"required,oneof=non_fungible_tokens fungible_tokens statistics currencies"`
}

type FungibleTokenInput struct {
	Contract *ContractInput `json:"contract" validate:"required,dive"`
}

type GetAllCurrenciesInput struct {
	Currencies *[]GetCurrencyInput `validate:"required"`
}

type GetAllFungibleTokensInput struct {
	Tokens *[]GetFungibleTokenInput `validate:"required"`
}

type GetAllInteractionsInput struct {
	Interactions *[]GetInteractionInput `validate:"required"`
}

type GetAllNonFungibleTokensInput struct {
	NonFungibleTokens *[]GetNonFungibleTokenInput `validate:"required"`
}

type GetAllStatisticsInput struct {
	Stats *[]GetStatisticsInput `validate:"required"`
}

type GetChallengeInput struct {
	Address string `validate:"required,eth_addr"`
}

type GetCurrencyInput struct {
	Address    string            `validate:"required,eth_addr"`
	Blockchain common.Blockchain `validate:"required,oneof=ethereum polygon arbitrum optimism"`
}

type GetDefaultProfileInput struct {
	Address string `validate:"required,eth_addr"`
}

type GetFungibleTokenInput struct {
	Address string              `validate:"required,eth_addr"`
	Token   *FungibleTokenInput `validate:"required,dive"`
}

type GetInteractionInput struct {
	Address     string            `validate:"required,eth_addr"`
	Interaction *InteractionInput `validate:"required,dive"`
}

type GetLightProfileInput struct {
	Address string `validate:"required,eth_addr"`
}

type GetNonFungibleTokenInput struct {
	Address          string                 `validate:"required,eth_addr"`
	NonFungibleToken *NonFungibleTokenInput `validate:"required,dive"`
}

type GetProfileInput struct {
	Address string `validate:"required,eth_addr"`
}

type GetSpotlightProfilesInput struct {
}

type GetStatisticsInput struct {
	Address   string          `validate:"required,eth_addr"`
	Statistic *StatisticInput `validate:"required,dive"`
}

type GetTopProfilesInput struct {
}

type IGetAllCurrenciesUseCase interface {
	// Get the balances for the given list of addresses and blockchains.
	// A nil balance will be returned for any invalid contracts
	Do(ctx context.Context, input *GetAllCurrenciesInput) *[]entities.Currency
}

type IGetAllFungibleTokensUseCase interface {
	// Get a slice of fungible tokens for the given contracts/address.
	// Invalid contracts will return a token with a zeroed balance.
	Do(ctx context.Context, input *GetAllFungibleTokensInput) *[]entities.FungibleToken
}

type IGetAllInteractionsUseCase interface {
	// Get all interactions.
	// A non nil error will be returned if any interactions in the list are invalid
	Do(ctx context.Context, input *GetAllInteractionsInput) (*[]entities.Interaction, error)
}

type IGetAllNonFungibleTokensUseCase interface {
	// Get the metadata and balance of a slice of nfts.
	// Invalid contracts have a zeroed balance and nil metadata returned.
	Do(ctx context.Context, input *GetAllNonFungibleTokensInput) *[]entities.NonFungibleToken
}

type IGetAllStatisticsUseCase interface {
	// Get all statistic data for a given slice of statistics.
	// Invalid contracts will return a statistic with nil Data.
	Do(ctx context.Context, input *GetAllStatisticsInput) *[]entities.Statistic
}

type IGetChallengeUseCase interface {
	// Get a new challenge message for the provided address
	Do(ctx context.Context, input *GetChallengeInput) (*entities.Challenge, error)
}

type IGetCurrencyUseCase interface {
	// Get the balance for a given address and blockchain
	Do(ctx context.Context, input *GetCurrencyInput) (*entities.Currency, error)
}

type IGetDefaultProfileUseCase interface {
	// Get a default profile for the provided address
	Do(ctx context.Context, input *GetDefaultProfileInput) (*entities.Profile, error)
}

type IGetFungibleTokenUseCase interface {
	// Get the metadata and balance of an nft
	Do(ctx context.Context, input *GetFungibleTokenInput) (*entities.FungibleToken, error)
}

type IGetInteractionUseCase interface {
	// Get the transaction data for a given interaction input
	// Validate transaction against interaction type
	Do(ctx context.Context, input *GetInteractionInput) (*entities.Interaction, error)
}

type IGetLightProfileUseCase interface {
	// get a minimaly hydrated version of the profile that will be faster to fetch
	Do(ctx context.Context, input *GetLightProfileInput) (*entities.Profile, error)
}

type IGetNonFungibleTokenUseCase interface {
	// Get the metadata and balance of an nft.
	// Metadata doesnt change so we cache it.
	// Metadata is an optional implementation in ERC721 and ERC1155 and may not exist.
	// Its also possible that we simply have issues following the uri.
	// In these scenarios we will return nil metadata and not bubble up an err.
	Do(ctx context.Context, input *GetNonFungibleTokenInput) (*entities.NonFungibleToken, error)
}

type IGetProfileUseCase interface {
	// get the profile for the provided address
	Do(ctx context.Context, input *GetProfileInput) (*entities.Profile, error)
}

type IGetSpotlightProfilesUseCase interface {
	Do(ctx context.Context, input *GetSpotlightProfilesInput) *[]entities.Profile
}

type IGetStatisticUseCase interface {
	// Get the statistic for a given address and contract
	Do(ctx context.Context, input *GetStatisticsInput) (*entities.Statistic, error)
}

type IGetTopProfilesUseCase interface {
	Do(ctx context.Context, input *GetTopProfilesInput) *[]entities.Profile
}

type IRecordProfileViewUseCase interface {
	Do(ctx context.Context, input *RecordProfileViewInput) error
}

type IRefreshProfileUseCase interface {
	// Refresh any relevant transient info that is currently cached.
	// Info that is currently refreshed:
	//
	// - Store Assets
	Do(ctx context.Context, input *RefreshProfileInput) error
}

type IResolveAddressUseCase interface {
	// Resolve an address from an ens name
	Do(ctx context.Context, input *ResolveAddressInput) (string, error)
}

type IResolveENSNameUseCase interface {
	// Resolve an ens name for an address
	Do(ctx context.Context, input *ResolveENSNameInput) (name string, err error)
}

type ISaveProfileUseCase interface {
	// Validate the non transient info being submitted (interactions).
	// Save the profile to the database.
	// Remove the cached profile.
	//
	// TODO: can fetch interactions and premium balance concurrently.
	Do(ctx context.Context, input *SaveProfileInput) error
}

type IVerifyChallengeUseCase interface {
	// verify if the provided signature was signed with the correct address and signed the correct challenge message
	Do(ctx context.Context, input *VerifyChallengeInput) error
}

type IVerifyRateLimitUseCase interface {
	// Verify that the provided IpAddress is not rate limited
	Do(ctx context.Context, input *VerifyRateLimitInput) error
}

type InteractionInput struct {
	Transaction *TransactionInput  `json:"transaction" validate:"required,dive"`
	Type        common.Interaction `json:"type" validate:"required,oneof=CONTRACT_CREATION SEND_ETHER"`
}

type NonFungibleTokenInput struct {
	Contract *ContractInput `json:"contract" validate:"required,dive"`
	TokenId  string         `json:"token_id" validate:"required,numeric"`
}

type ProfileInput struct {
	Address           string                   `json:"-" validate:"required,eth_addr"`
	DisplayConfig     *DisplayConfigInput      `json:"display_config" validate:"required,dive"`
	ProfilePicture    *NonFungibleTokenInput   `json:"profile_picture" validate:"omitempty,dive"`
	NonFungibleTokens *[]NonFungibleTokenInput `json:"non_fungible_tokens" validate:"required,dive"`
	FungibleTokens    *[]FungibleTokenInput    `json:"fungible_tokens" validate:"required,dive"`
	Statistics        *[]StatisticInput        `json:"statistics" validate:"required,dive"`
	Interactions      *[]InteractionInput      `json:"interactions" validate:"required,dive"`
	Currencies        *[]CurrencyInput         `json:"currencies" validate:"required,dive"`
}

type RecordProfileViewInput struct {
	Address   string `validate:"required,eth_addr"`
	IpAddress string `validate:"required,ip"`
}

type RefreshProfileInput struct {
	Address string `validate:"required,eth_addr"`
}

type ResolveAddressInput struct {
	Value string `validate:"required"`
}

type ResolveENSNameInput struct {
	Address string `validate:"required,eth_addr"`
}

type SaveProfileInput struct {
	Profile *ProfileInput `validate:"required,dive"`
}

type StatisticInput struct {
	Contract *ContractInput       `json:"contract" validate:"required,dive"`
	Type     common.StatisticType `json:"type" validate:"required,oneof=SWAP STAKE"`
}

type TransactionInput struct {
	Id         string            `json:"id" validate:"required"`
	Blockchain common.Blockchain `json:"blockchain" validate:"required,oneof=ethereum polygon arbitrum optimism"`
}

type VerifyChallengeInput struct {
	Address string `validate:"required,eth_addr"`
	SigHex  string `validate:"required"`
}

type VerifyRateLimitInput struct {
	IpAddress string `validate:"required,ip"`
}