dao

var (
	ErrUnsupportedKeyType                 = errors.New("unsupported key type")
	ErrInvalidKeyLength                   = errors.New("invalid key length")
	ErrUnsupportedKeyUsage                = errors.New("unsupported key usage")
	ErrInvalidCertificateRequestSignature = errors.New("invalid certificate request signature")
	ErrInvalidSignature                   = errors.New("invalid certificate signature")
	ErrNotBeforeRange                     = errors.New("not before limit exceeded")
	ErrNotAfterRange                      = errors.New("not after limit exceeded")
)

var AutoseedConfig = NewSingleton(
	autoseedConfigNS,
	&SingletonOptions[autoseedv1.Config, *autoseedv1.Config]{
		DefaultValue: &autoseedv1.Config{},
		ObserveChange: func(m, p *autoseedv1.Config) proto.Message {
			return &autoseedv1.ConfigChangeEvent{Config: m}
		},
	},
)

var AutoseedRules = NewTable(
	autoseedRuleNS,
	&TableOptions[autoseedv1.Rule, *autoseedv1.Rule]{
		ObserveChange: func(m, p *autoseedv1.Rule) proto.Message {
			return &autoseedv1.RuleChangeEvent{Rule: m}
		},
		ObserveDelete: func(m *autoseedv1.Rule) proto.Message {
			return &autoseedv1.RuleDeleteEvent{Rule: m}
		},
	},
)

var BootstrapClients = NewTable(
	networkBootstrapClientNS,
	&TableOptions[networkv1bootstrap.BootstrapClient, *networkv1bootstrap.BootstrapClient]{
		ObserveChange: func(m, p *networkv1bootstrap.BootstrapClient) proto.Message {
			return &networkv1bootstrap.BootstrapClientChange{BootstrapClient: m}
		},
	},
)

var BootstrapClientsByClientOptions = NewUniqueIndex(
	networkBootstrapClientClientOptionsNS,
	BootstrapClients,
	FormatBootstrapClientClientOptionsKey,
	byteIdentity,
	&UniqueIndexOptions[networkv1bootstrap.BootstrapClient, *networkv1bootstrap.BootstrapClient]{
		OnConflict: func(s kv.RWStore, t *Table[networkv1bootstrap.BootstrapClient, *networkv1bootstrap.BootstrapClient], m, p *networkv1bootstrap.BootstrapClient) error {
			return BootstrapClients.Delete(s, p.GetId())
		},
	},
)

var BootstrapConfig = NewSingleton(
	bootstrapConfigNS,
	&SingletonOptions[networkv1bootstrap.Config, *networkv1bootstrap.Config]{
		DefaultValue: &networkv1bootstrap.Config{
			EnablePublishing: false,
		},
		ObserveChange: func(m, p *networkv1bootstrap.Config) proto.Message {
			return &networkv1bootstrap.ConfigChangeEvent{Config: m}
		},
	},
)

var CertificateLogs = NewTable[networkv1ca.CertificateLog](networkCertificateLogNS, nil)

var CertificateLogsByKey = NewUniqueIndex(
	networkCertificateLogKeyNS,
	CertificateLogs,
	certificateLogKeyKey,
	byteIdentity,
	&UniqueIndexOptions[networkv1ca.CertificateLog, *networkv1ca.CertificateLog]{
		OnConflict: func(s kv.RWStore, t *Table[networkv1ca.CertificateLog, *networkv1ca.CertificateLog], m, p *networkv1ca.CertificateLog) error {
			return DeleteSecondaryIndex(s, networkCertificateLogKeyNS, certificateLogKeyKey(m), p.Id)
		},
	},
)

var CertificateLogsByNetwork = ManyToOne(
	networkCertificateLogNetworkNS,
	CertificateLogs,
	Networks,
	(*networkv1ca.CertificateLog).GetNetworkId,
	&ManyToOneOptions[networkv1ca.CertificateLog, *networkv1ca.CertificateLog]{CascadeDelete: true},
)

var CertificateLogsBySerialNumber = NewUniqueIndex(
	networkCertificateLogSerialNS,
	CertificateLogs,
	certificateLogSerialNumberKey,
	byteIdentity,
	nil,
)

var CertificateLogsBySubject = NewUniqueIndex(
	networkCertificateLogSubjectNS,
	CertificateLogs,
	certificateLogSubjectKey,
	byteIdentity,
	&UniqueIndexOptions[networkv1ca.CertificateLog, *networkv1ca.CertificateLog]{
		OnConflict: func(s kv.RWStore, t *Table[networkv1ca.CertificateLog, *networkv1ca.CertificateLog], m, p *networkv1ca.CertificateLog) error {
			return DeleteSecondaryIndex(s, networkCertificateLogSubjectNS, certificateLogSubjectKey(m), p.Id)
		},
	},
)

var ChatEmotes = NewTable(
	chatEmoteNS,
	&TableOptions[chatv1.Emote, *chatv1.Emote]{
		ObserveChange: func(m, p *chatv1.Emote) proto.Message {
			return &chatv1.EmoteChangeEvent{Emote: m}
		},
		ObserveDelete: func(m *chatv1.Emote) proto.Message {
			return &chatv1.EmoteDeleteEvent{Emote: m}
		},
	},
)

var ChatEmotesByServer = ManyToOne(
	chatEmoteServerNS,
	ChatEmotes,
	ChatServers,
	(*chatv1.Emote).GetServerId,
	&ManyToOneOptions[chatv1.Emote, *chatv1.Emote]{CascadeDelete: true},
)

var ChatModifiers = NewTable(
	chatModifierNS,
	&TableOptions[chatv1.Modifier, *chatv1.Modifier]{
		ObserveChange: func(m, p *chatv1.Modifier) proto.Message {
			return &chatv1.ModifierChangeEvent{Modifier: m}
		},
		ObserveDelete: func(m *chatv1.Modifier) proto.Message {
			return &chatv1.ModifierDeleteEvent{Modifier: m}
		},
	},
)

var ChatModifiersByServer = ManyToOne(
	chatModifierServerNS,
	ChatModifiers,
	ChatServers,
	(*chatv1.Modifier).GetServerId,
	&ManyToOneOptions[chatv1.Modifier, *chatv1.Modifier]{CascadeDelete: true},
)

var ChatProfiles = NewTable[chatv1.Profile](chatProfileNS, nil)

var ChatProfilesByPeerKey = NewUniqueIndex(chatProfilePeerKeyNS, ChatProfiles, chatProfilePeerKey, byteIdentity, nil)

var ChatProfilesByServer = ManyToOne(
	chatProfileServerNS,
	ChatProfiles,
	ChatServers,
	(*chatv1.Profile).GetServerId,
	&ManyToOneOptions[chatv1.Profile, *chatv1.Profile]{CascadeDelete: true},
)

var ChatServerIcons = NewTable(
	chatServerIconNS,
	&TableOptions[chatv1.ServerIcon, *chatv1.ServerIcon]{
		ObserveChange: func(m, p *chatv1.ServerIcon) proto.Message {
			return &chatv1.ServerIconChangeEvent{ServerIcon: m}
		},
	},
)

var ChatServers = NewTable(
	chatServerNS,
	&TableOptions[chatv1.Server, *chatv1.Server]{
		ObserveChange: func(m, p *chatv1.Server) proto.Message {
			return &chatv1.ServerChangeEvent{Server: m}
		},
		ObserveDelete: func(m *chatv1.Server) proto.Message {
			return &chatv1.ServerDeleteEvent{Server: m}
		},
	},
)

var ChatTags = NewTable(
	chatTagNS,
	&TableOptions[chatv1.Tag, *chatv1.Tag]{
		ObserveChange: func(m, p *chatv1.Tag) proto.Message {
			return &chatv1.TagChangeEvent{Tag: m}
		},
		ObserveDelete: func(m *chatv1.Tag) proto.Message {
			return &chatv1.TagDeleteEvent{Tag: m}
		},
	},
)

var ChatTagsByServer = ManyToOne(
	chatTagServerNS,
	ChatTags,
	ChatServers,
	(*chatv1.Tag).GetServerId,
	&ManyToOneOptions[chatv1.Tag, *chatv1.Tag]{CascadeDelete: true},
)

var ChatUIConfig = NewSingleton(
	chatUIConfigNS,
	&SingletonOptions[chatv1.UIConfig, *chatv1.UIConfig]{
		ObserveChange: func(m, p *chatv1.UIConfig) proto.Message {
			return &chatv1.UIConfigChangeEvent{UiConfig: m}
		},
	},
)

var ChatUIConfigHighlights = NewTable(
	chatUIConfigHighlightNS,
	&TableOptions[chatv1.UIConfigHighlight, *chatv1.UIConfigHighlight]{
		ObserveChange: func(m, p *chatv1.UIConfigHighlight) proto.Message {
			return &chatv1.UIConfigHighlightChangeEvent{UiConfigHighlight: m}
		},
		ObserveDelete: func(m *chatv1.UIConfigHighlight) proto.Message {
			return &chatv1.UIConfigHighlightDeleteEvent{UiConfigHighlight: m}
		},
	},
)

var ChatUIConfigHighlightsByPeerKey = NewUniqueIndex(chatUIConfigHighlightKeyNS, ChatUIConfigHighlights, (*chatv1.UIConfigHighlight).GetPeerKey, byteIdentity, nil)

var ChatUIConfigIgnores = NewTable(
	chatUIConfigIgnoreNS,
	&TableOptions[chatv1.UIConfigIgnore, *chatv1.UIConfigIgnore]{
		ObserveChange: func(m, p *chatv1.UIConfigIgnore) proto.Message {
			return &chatv1.UIConfigIgnoreChangeEvent{UiConfigIgnore: m}
		},
		ObserveDelete: func(m *chatv1.UIConfigIgnore) proto.Message {
			return &chatv1.UIConfigIgnoreDeleteEvent{UiConfigIgnore: m}
		},
	},
)

var ChatUIConfigIgnoresByPeerKey = NewUniqueIndex(chatUIConfigIgnoreKeyNS, ChatUIConfigIgnores, (*chatv1.UIConfigIgnore).GetPeerKey, byteIdentity, nil)

var ChatUIConfigTags = NewTable(
	chatUIConfigTagNS,
	&TableOptions[chatv1.UIConfigTag, *chatv1.UIConfigTag]{
		ObserveChange: func(m, p *chatv1.UIConfigTag) proto.Message {
			return &chatv1.UIConfigTagChangeEvent{UiConfigTag: m}
		},
		ObserveDelete: func(m *chatv1.UIConfigTag) proto.Message {
			return &chatv1.UIConfigTagDeleteEvent{UiConfigTag: m}
		},
	},
)

var ChatUIConfigTagsByPeerKey = NewUniqueIndex(chatUIConfigTagKeyNS, ChatUIConfigTags, (*chatv1.UIConfigTag).GetPeerKey, byteIdentity, nil)

var ChatWhisperRecords = NewTable(
	chatWhisperRecordNS,
	&TableOptions[chatv1.WhisperRecord, *chatv1.WhisperRecord]{
		ObserveChange: func(m, p *chatv1.WhisperRecord) proto.Message {
			return &chatv1.WhisperRecordChangeEvent{WhisperRecord: m}
		},
		ObserveDelete: func(m *chatv1.WhisperRecord) proto.Message {
			return &chatv1.WhisperRecordDeleteEvent{WhisperRecord: m}
		},
	},
)

var ChatWhisperRecordsByPeerKey = NewSecondaryIndex(
	chatWhisperRecordPeerKeyNS,
	ChatWhisperRecords,
	(*chatv1.WhisperRecord).GetPeerKey,
	byteIdentity,
	nil,
)

var ChatWhisperRecordsByPeerMessageID = NewUniqueIndex(
	chatWhisperRecordPeerMessageIDKeyNS,
	ChatWhisperRecords,
	FormatChatWhisperRecordPeerMessageIDKey,
	byteIdentity,
	&UniqueIndexOptions[chatv1.WhisperRecord, *chatv1.WhisperRecord]{
		SecondaryIndexOptions: SecondaryIndexOptions[chatv1.WhisperRecord, *chatv1.WhisperRecord]{
			Condition: func(m *chatv1.WhisperRecord) bool {
				return m.PeerMessageId != 0
			},
		},
	},
)

var ChatWhisperRecordsByState = NewSecondaryIndex(
	chatWhisperRecordStateNS,
	ChatWhisperRecords,
	func(m *chatv1.WhisperRecord) []byte { return FormatChatWhisperRecordStateKey(m.State) },
	byteIdentity,
	nil,
)

var ChatWhisperThreads = NewTable(
	chatWhisperThreadNS,
	&TableOptions[chatv1.WhisperThread, *chatv1.WhisperThread]{
		ObserveChange: func(m, p *chatv1.WhisperThread) proto.Message {
			return &chatv1.WhisperThreadChangeEvent{WhisperThread: m}
		},
		ObserveDelete: func(m *chatv1.WhisperThread) proto.Message {
			return &chatv1.WhisperThreadDeleteEvent{WhisperThread: m}
		},
		OnDelete: LocalDeleteHook(func(s ReplicatedRWTx, p *chatv1.WhisperThread) error {
			_, err := ChatWhisperRecordsByPeerKey.DeleteAll(s, p.PeerKey)
			return err
		}),
	},
)

var ChatWhisperThreadsByPeerKey = NewUniqueIndex(
	chatWhisperThreadPeerKeyNS,
	ChatWhisperThreads,
	(*chatv1.WhisperThread).GetPeerKey,
	byteIdentity,
	&UniqueIndexOptions[chatv1.WhisperThread, *chatv1.WhisperThread]{
		OnConflict: func(s kv.RWStore, t *Table[chatv1.WhisperThread, *chatv1.WhisperThread], m, p *chatv1.WhisperThread) error {
			resolveChatWhisperThreadConflict(m, p)
			return ChatWhisperThreads.Delete(s, p.Id)
		},
	},
)

var DebugConfig = NewSingleton(
	debugConfigNS,
	&SingletonOptions[debugv1.Config, *debugv1.Config]{
		DefaultValue: &debugv1.Config{},
		ObserveChange: func(m, p *debugv1.Config) proto.Message {
			return &debugv1.ConfigChangeEvent{Config: m}
		},
	},
)

var DefaultStoreOptions = CacheStoreOptions{
	TTL:        10 * time.Minute,
	GCInterval: 1 * time.Second,
	Cap:        math.MaxInt,
}

var Devices = NewTable(
	profileDeviceNS,
	&TableOptions[profilev1.Device, *profilev1.Device]{
		ObserveChange: func(m, p *profilev1.Device) proto.Message {
			return &profilev1.DeviceChangeEvent{Device: m}
		},
		ObserveDelete: func(m *profilev1.Device) proto.Message {
			return &profilev1.DeviceDeleteEvent{Device: m}
		},
	},
)

var DirectoryListingRecords = NewTable[networkv1directory.ListingRecord](directoryListingRecordNS, nil)

var DirectoryListingRecordsByListing = NewUniqueIndex(
	directoryListingRecordListingNS,
	DirectoryListingRecords,
	directoryListingKey,
	byteIdentity,
	nil,
)

var DirectoryListingRecordsByNetwork = ManyToOne(
	directoryListingRecordNetworkNS,
	DirectoryListingRecords,
	Networks,
	(*networkv1directory.ListingRecord).GetNetworkId,
	&ManyToOneOptions[networkv1directory.ListingRecord, *networkv1directory.ListingRecord]{CascadeDelete: true},
)

var DirectoryUserRecords = NewTable[networkv1directory.UserRecord](directoryUserRecordNS, nil)

var DirectoryUserRecordsByNetwork = ManyToOne(
	directoryUserRecordNetworkNS,
	DirectoryUserRecords,
	Networks,
	(*networkv1directory.UserRecord).GetNetworkId,
	&ManyToOneOptions[networkv1directory.UserRecord, *networkv1directory.UserRecord]{CascadeDelete: true},
)

var DirectoryUserRecordsByPeerKey = NewUniqueIndex(
	directoryUserRecordPeerKeyNS,
	DirectoryUserRecords,
	directoryUserRecordPeerKeyKey,
	byteIdentity,
	nil,
)

var ErrCertificateSubjectInUse = errors.New("certificate subject in use")

var ErrLockBusy = errors.New("failed to update busy lock")

var ErrReplicatorNotFound = errors.New("replicator not found")

var ErrUniqueConstraintViolated = errors.New("unique constraint violated")

var ErrUnsupportedKDFType = errors.New("unsupported key derivation function")

var HLSEgressConfig = NewSingleton(
	videoHLSEgressConfigNS,
	&SingletonOptions[videov1.HLSEgressConfig, *videov1.HLSEgressConfig]{
		DefaultValue: &videov1.HLSEgressConfig{},
		ObserveChange: func(m, p *videov1.HLSEgressConfig) proto.Message {
			return &videov1.HLSEgressConfigChangeEvent{EgressConfig: m}
		},
	},
)

var Logger = zap.NewNop()

var NetworkAliasReservations = NetworkAliasReservationTable{NewTable[networkv1.AliasReservation](networkAliasReservationNS, nil)}

var NetworkAliasReservationsByAlias = NewUniqueIndex(
	networkAliasReservationsByAliasNS,
	NetworkAliasReservations.Table,
	func(m *networkv1.AliasReservation) []byte {
		return FormatNetworkAliasReservationAliasKey(m.NetworkId, m.Alias)
	},
	byteIdentity,
	nil,
)

var NetworkAliasReservationsByNetwork = ManyToOne(
	networkAliasReservationsByNetworkIDNS,
	NetworkAliasReservations.Table,
	Networks,
	(*networkv1.AliasReservation).GetNetworkId,
	nil,
)

var NetworkPeers = NewTable[networkv1.Peer](networkPeerNS, nil)

var NetworkPeersByInviterPeer = ManyToOne(
	networkPeerInviterNS,
	NetworkPeers,
	NetworkPeers,
	(*networkv1.Peer).GetInviterPeerId,
	nil,
)

var NetworkPeersByNetwork = ManyToOne(
	networkPeerNetworkNS,
	NetworkPeers,
	Networks,
	(*networkv1.Peer).GetNetworkId,
	&ManyToOneOptions[networkv1.Peer, *networkv1.Peer]{CascadeDelete: true},
)

var NetworkPeersByPublicKey = NewUniqueIndex(
	networkPeerPublicKeyNS,
	NetworkPeers,
	func(m *networkv1.Peer) []byte {
		return FormatNetworkPeerPublicKeyKey(m.NetworkId, m.PublicKey)
	},
	byteIdentity,
	nil,
)

var NetworkUIConfig = NewSingleton(
	networkUIConfigNS,
	&SingletonOptions[networkv1.UIConfig, *networkv1.UIConfig]{
		DefaultValue: &networkv1.UIConfig{
			NetworkDisplayOrder: []uint64{},
		},
		ObserveChange: func(m, p *networkv1.UIConfig) proto.Message {
			return &networkv1.UIConfigChangeEvent{UiConfig: m}
		},
	},
)

var Networks = NewTable(
	networkNetworkNS,
	&TableOptions[networkv1.Network, *networkv1.Network]{
		ObserveChange: func(m, p *networkv1.Network) proto.Message {
			return &networkv1.NetworkChangeEvent{Network: m}
		},
		ObserveDelete: func(m *networkv1.Network) proto.Message {
			return &networkv1.NetworkDeleteEvent{Network: m}
		},
		OnChange: LocalSetHook(func(s ReplicatedRWTx, m, p *networkv1.Network) error {
			if p != nil || m.GetServerConfig() == nil {
				return nil
			}

			for c := m.Certificate; c != nil; c = c.GetParent() {
				log, err := NewCertificateLog(ProfileID.IDGenerator(s), m.Id, c)
				if err != nil {
					return err
				}
				if err := CertificateLogs.Insert(s, log); err != nil {
					return err
				}
			}

			peer, err := NewNetworkPeer(ProfileID.IDGenerator(s), m.Id, m.Certificate.Key, m.Certificate.Subject, 0)
			if err != nil {
				return err
			}
			if err := NetworkPeers.Insert(s, peer); err != nil {
				return err
			}

			aliasReservation, err := NewNetworkAliasReservation(ProfileID.IDGenerator(s), m.Id, m.Certificate.Subject, m.Certificate.Key)
			if err != nil {
				return err
			}
			if err := NetworkAliasReservations.Insert(s, aliasReservation); err != nil {
				return err
			}

			directoryUser, err := NewDirectoryUserRecord(ProfileID.IDGenerator(s), m.Id, m.Certificate.Key)
			if err != nil {
				return err
			}
			directoryUser.Moderation.IsAdmin = wrapperspb.Bool(true)
			directoryUser.Moderation.IsModerator = wrapperspb.Bool(true)
			return DirectoryUserRecords.Insert(s, directoryUser)
		}),
	},
)

var NetworksByKey = NewUniqueIndex(
	networkNetworkKeyNS,
	Networks,
	NetworkKey,
	byteIdentity,
	&UniqueIndexOptions[networkv1.Network, *networkv1.Network]{
		OnConflict: func(s kv.RWStore, t *Table[networkv1.Network, *networkv1.Network], m, p *networkv1.Network) error {

			if p.ServerConfig != nil {
				return ErrUniqueConstraintViolated
			}
			resolveNetworkConflict(m, p)
			return Networks.Delete(s, p.Id)
		},
	},
)

var Notifications = NewTable(
	notificationNotificationNS,
	&TableOptions[notificationv1.Notification, *notificationv1.Notification]{
		ObserveChange: func(m, p *notificationv1.Notification) proto.Message {
			return &notificationv1.NotificationChangeEvent{Notification: m}
		},
		ObserveDelete: func(m *notificationv1.Notification) proto.Message {
			return &notificationv1.NotificationDeleteEvent{Notification: m}
		},
	},
)

var Profile = NewSingleton[profilev1.Profile](profileProfileNS, nil)

var ProfileID = ProfileIDSingleton{
	NewSingleton(
		profileIDNS,
		&SingletonOptions[profilev1.ProfileID, *profilev1.ProfileID]{
			DefaultValue: &profilev1.ProfileID{
				NextId: 1,
				LastId: math.MaxUint64,
			},
		},
	),
}

var ReplicationCheckpoints = ReplicationCheckpointTable{
	NewTable(
		replicationVersionNS,
		&TableOptions[replicationv1.Checkpoint, *replicationv1.Checkpoint]{
			OnChange: func(s kv.RWStore, m, p *replicationv1.Checkpoint) error {
				if p != nil {
					versionvector.Upgrade(m.Version, p.Version)
					m.Deleted = m.Deleted || p.Deleted
				}
				return nil
			},
			ObserveChange: func(m, p *replicationv1.Checkpoint) proto.Message {
				return &replicationv1.CheckpointChangeEvent{Checkpoint: m}
			},
		},
	),
}

var ReplicationEventLogs = ReplicationEventLogTable{
	NewTable[replicationv1.EventLog](replicationLogNS, nil),
}

var UnreadChatWhisperRecordsByPeerKey = NewSecondaryIndex(
	chatWhisperRecordWhisperUnreadNS,
	ChatWhisperRecords,
	(*chatv1.WhisperRecord).GetPeerKey,
	byteIdentity,
	&SecondaryIndexOptions[chatv1.WhisperRecord, *chatv1.WhisperRecord]{
		Condition: func(m *chatv1.WhisperRecord) bool {
			return m.State == chatv1.MessageState_MESSAGE_STATE_UNREAD
		},
	},
)

var VNICConfig = NewSingleton(
	vnicConfigNS,
	&SingletonOptions[vnicv1.Config, *vnicv1.Config]{
		DefaultValue: &vnicv1.Config{
			MaxUploadBytesPerSecond: 1 << 40,
			MaxPeers:                25,
		},
		ObserveChange: func(m, p *vnicv1.Config) proto.Message {
			return &vnicv1.ConfigChangeEvent{Config: m}
		},
	},
)

var VideoChannels = NewTable(
	videoChannelNS,
	&TableOptions[videov1.VideoChannel, *videov1.VideoChannel]{
		ObserveChange: func(m, p *videov1.VideoChannel) proto.Message {
			return &videov1.VideoChannelChangeEvent{VideoChannel: m}
		},
		ObserveDelete: func(m *videov1.VideoChannel) proto.Message {
			return &videov1.VideoChannelDeleteEvent{VideoChannel: m}
		},
	},
)

var VideoIngressConfig = NewSingleton(
	videoIngressConfigNS,
	&SingletonOptions[videov1.VideoIngressConfig, *videov1.VideoIngressConfig]{
		DefaultValue: &videov1.VideoIngressConfig{
			ServerAddr: "127.0.0.1:1935",
		},
		ObserveChange: func(m, p *videov1.VideoIngressConfig) proto.Message {
			return &videov1.VideoIngressConfigChangeEvent{IngressConfig: m}
		},
	},
)