api

type Controller struct {
	Path   string
	Routes []*Route
}

type Database[T any] interface {
	WaitForStart()
	GetClient() T
	GetName() string
	Connect() error
	Disconnect() error
	Ping() bool
}

type DatabaseService interface {
	ServiceStarter
	AutoReconnect(database Database[any]) error
	Postgres() Database[*gorm.DB]
	Redis() Database[RedisClient]
}

type Duration time.Duration

type ExternalServicesService interface {
	ServiceInitializer
	Wakatime() WakatimeService
	Github() GithubService
}

type GithubService interface {
	ListRepositoriesConcurrent(callback ListRepositoriesCallback) error
}

type Handler func(c *gin.Context, user User, mainService MainService)

type HeartbeatsResponse[T float64 | Duration] struct {
	Data []HeartbeatsResponseData[T] `json:"data"`
}

type HeartbeatsResponseData[T float64 | Duration] struct {
	Time T `json:"time"`
}

type HttpMethod int

type HttpService interface {
	ServiceInitializer
	ServiceStarter
	Engine() *gin.Engine
	RegisterRoutes(...*Route)
	RegisterControllers(...*Controller)
}

type ListRepositoriesCallback func(repositories []*github.Repository, wg *sync.WaitGroup)

type MainService interface {
	Init() error
	Start(errCh chan error)
	Close() error
	Databases() DatabaseService
	Http() HttpService
	Projects() ProjectService
	ExternalServices() ExternalServicesService
	Stats() StatsService
	Tasks() TasksService
	Messages() MessagesService
	Users() UsersService
}

type MessagesService interface {
	ServiceInitializer
	GetAllMessagesFromScopeId(scopeId uuid.UUID) (messages []*model.Message, err error)
	GetAllMessagesFromScope(scope string) (messages []*model.Message, err error)
	GetMessage(scope, key string) (message *model.Message, err error)
	AddMessage(message *model.Message) (err error)
	UpdateMessage(message *model.Message) (err error)
	AddTranslations(message *model.Message) (err error)
	GetScopeFromName(scopeName string) (scope *model.Scope, err error)
}

type MiddlewareHandler func(c *gin.Context, user User, mainService MainService) (next bool)

type ProjectService interface {
	ServiceInitializer
	GetProject(id uint) (*model.Project, error)
	ListProjects() ([]*model.Project, error)
}

type RedisClient interface {
	Base() *redis.Client
	ReJson() *rejson.Handler
	GetJsonString(key, path string) (string, error)
	GetJsonInt(key, path string) (int, error)
	GetJsonFloat(key, path string) (float64, error)
	GetJsonBool(key, path string) (bool, error)
	GetJsonObject(key, path string, object interface{}) error
}

type RepositoriesStored struct {
	PublicRepositories      int `json:"publicRepositories"`
	PrivateRepositories     int `json:"privateRepositories"`
	PublicOwnedRepositories int `json:"publicOwnedRepositories"`
}

type Route struct {
	Path                   string
	Method                 HttpMethod
	IsAuthenticated        bool
	AuthenticateMiddleware func(c *gin.Context, user User, mainService MainService)
	Middlewares            []MiddlewareHandler
	Handler                Handler
}

type ServiceInitializer interface {
	Init(service MainService) error
}

type ServiceSettings struct {
	MustWaitForStart bool
	Priority         int
}

type ServiceStarter interface {
	Start() error
	Close() error
	Settings() ServiceSettings
}

type StatsService interface {
	ServiceInitializer
	GetTotalDevTime() (*TotalDevTimeResponse[Duration], error)
	GetBestDevTimeDay() (Duration, error)
	IsDeveloping() (bool, error)
	GetVisitorCount() (int, error)
	ListRepositories() (*RepositoriesStored, error)
}

type TasksService interface {
	ServiceInitializer
	ServiceStarter
	CheckWakatimeActivityTask() error
}

type TotalDevTimeResponse[T float64 | Duration] struct {
	Data TotalDevTimeResponseData[T] `json:"data"`
}

type TotalDevTimeResponseData[T float64 | Duration] struct {
	Range        TotalDevTimeResponseDataRange `json:"range"`
	TotalSeconds T                             `json:"total_seconds"`
}

type TotalDevTimeResponseDataRange struct {
	Start time.Time `json:"start"`
}

type User interface {
	GetId() uint
	GetUsername() string
	GetEmail() string
	GetPassword() string
	GetPermissions() []string
	HasPermission(permission string) bool
}

type UsersService interface {
	ServiceInitializer
	GetUser(id uint, withPassword ...bool) (User, error)
	GetUserByUsername(username string, withPassword ...bool) (User, error)
	GetUserByEmail(email string, withPassword ...bool) (User, error)
	ListUsers() ([]User, error)
	Register(user User) error
	IsExist(email string) bool
}

type WakatimeService interface {
	GetTotalDevTime() (*TotalDevTimeResponse[Duration], error)
	GetBestDevTimeDay() (Duration, error)
	GetTodayHeartbeats() (*HeartbeatsResponse[Duration], error)
	GetLastTodayHeartbeat() (Duration, error)
}