dcbot/internal/adapter/twhelp_http.go

package adapter

import (
	"context"
	"errors"
	"time"

	"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
	"gitea.dwysokinski.me/twhelp/dcbot/internal/twhelp"
)

type TWHelpHTTP struct {
	client *twhelp.Client
}

func NewTWHelpHTTP(client *twhelp.Client) *TWHelpHTTP {
	return &TWHelpHTTP{client: client}
}

func (t *TWHelpHTTP) ListVersions(ctx context.Context) ([]domain.TWVersion, error) {
	versions, err := t.client.ListVersions(ctx)
	if err != nil {
		return nil, err
	}

	res := make([]domain.TWVersion, 0, len(versions))
	for _, v := range versions {
		res = append(res, t.convertVersionToDomain(v))
	}

	return res, nil
}

func (t *TWHelpHTTP) ListOpenServers(ctx context.Context, version string, offset, limit int32) ([]domain.TWServer, error) {
	return t.listServers(ctx, version, twhelp.ListServersQueryParams{
		Limit:  limit,
		Offset: offset,
		Open: twhelp.NullBool{
			Bool:  true,
			Valid: true,
		},
	})
}

func (t *TWHelpHTTP) ListClosedServers(ctx context.Context, version string, offset, limit int32) ([]domain.TWServer, error) {
	return t.listServers(ctx, version, twhelp.ListServersQueryParams{
		Limit:  limit,
		Offset: offset,
		Open: twhelp.NullBool{
			Bool:  false,
			Valid: true,
		},
	})
}

func (t *TWHelpHTTP) listServers(ctx context.Context, version string, params twhelp.ListServersQueryParams) ([]domain.TWServer, error) {
	servers, err := t.client.ListServers(ctx, version, params)
	if err != nil {
		return nil, err
	}

	res := make([]domain.TWServer, 0, len(servers))
	for _, s := range servers {
		res = append(res, t.convertServerToDomain(s))
	}

	return res, nil
}

func (t *TWHelpHTTP) GetOpenServer(ctx context.Context, versionCode, serverKey string) (domain.TWServer, error) {
	server, err := t.GetServer(ctx, versionCode, serverKey)
	if err != nil {
		return domain.TWServer{}, err
	}
	if !server.Open {
		return domain.TWServer{}, domain.TWServerNotFoundError{
			VersionCode: versionCode,
			Key:         serverKey,
		}
	}
	return server, nil
}

func (t *TWHelpHTTP) GetServer(ctx context.Context, versionCode, serverKey string) (domain.TWServer, error) {
	server, err := t.client.GetServer(ctx, versionCode, serverKey)
	if err != nil {
		var apiErr twhelp.APIError
		if !errors.As(err, &apiErr) || apiErr.Code != twhelp.ErrorCodeEntityNotFound {
			return domain.TWServer{}, err
		}
		return domain.TWServer{}, domain.TWServerNotFoundError{
			VersionCode: versionCode,
			Key:         serverKey,
		}
	}
	return t.convertServerToDomain(server), nil
}

func (t *TWHelpHTTP) GetTribeByID(ctx context.Context, versionCode, serverKey string, id int64) (domain.Tribe, error) {
	tribe, err := t.client.GetTribeByID(ctx, versionCode, serverKey, id)
	if err != nil {
		var apiErr twhelp.APIError
		if !errors.As(err, &apiErr) || apiErr.Code != twhelp.ErrorCodeEntityNotFound {
			return domain.Tribe{}, err
		}
		return domain.Tribe{}, domain.TribeIDNotFoundError{
			VersionCode: versionCode,
			ServerKey:   serverKey,
			ID:          id,
		}
	}
	return t.convertTribeToDomain(tribe), nil
}

func (t *TWHelpHTTP) GetExistingTribeByTag(ctx context.Context, versionCode, serverKey, tribeTag string) (domain.Tribe, error) {
	tribes, err := t.client.ListTribes(ctx, versionCode, serverKey, twhelp.ListTribesQueryParams{
		Limit: 1,
		Tags:  []string{tribeTag},
		Deleted: twhelp.NullBool{
			Valid: true,
			Bool:  false,
		},
	})
	if err != nil {
		return domain.Tribe{}, err
	}

	if len(tribes) == 0 {
		return domain.Tribe{}, domain.TribeTagNotFoundError{
			VersionCode: versionCode,
			ServerKey:   serverKey,
			Tag:         tribeTag,
		}
	}

	return t.convertTribeToDomain(tribes[0]), nil
}

func (t *TWHelpHTTP) ListTribesByTag(
	ctx context.Context,
	versionCode, serverKey string,
	tribeTags []string,
	offset, limit int32,
) ([]domain.Tribe, error) {
	tribes, err := t.client.ListTribes(ctx, versionCode, serverKey, twhelp.ListTribesQueryParams{
		Limit:  limit,
		Offset: offset,
		Tags:   tribeTags,
		Deleted: twhelp.NullBool{
			Valid: true,
			Bool:  false,
		},
	})
	if err != nil {
		return nil, err
	}

	res := make([]domain.Tribe, 0, len(tribes))
	for _, tr := range tribes {
		res = append(res, t.convertTribeToDomain(tr))
	}

	return res, nil
}

func (t *TWHelpHTTP) ListVillagesByCoords(
	ctx context.Context,
	versionCode, serverKey string,
	coords []string,
	offset, limit int32,
) ([]domain.Village, error) {
	villages, err := t.client.ListVillages(ctx, versionCode, serverKey, twhelp.ListVillagesQueryParams{
		Limit:  limit,
		Offset: offset,
		Coords: coords,
	})
	if err != nil {
		return nil, err
	}

	res := make([]domain.Village, 0, len(villages))
	for _, v := range villages {
		res = append(res, t.convertVillageToDomain(v))
	}

	return res, nil
}

func (t *TWHelpHTTP) ListEnnoblementsSince(
	ctx context.Context,
	versionCode, serverKey string,
	since time.Time,
	offset, limit int32,
) ([]domain.Ennoblement, error) {
	ennoblements, err := t.client.ListEnnoblements(ctx, versionCode, serverKey, twhelp.ListEnnoblementsQueryParams{
		Limit:  limit,
		Offset: offset,
		Since:  since,
		Sort: []twhelp.EnnoblementSort{
			twhelp.EnnoblementSortCreatedAtASC,
		},
	})
	if err != nil {
		return nil, err
	}

	res := make([]domain.Ennoblement, 0, len(ennoblements))
	for _, e := range ennoblements {
		res = append(res, t.convertEnnoblementToDomain(e))
	}

	return res, nil
}

func (t *TWHelpHTTP) convertVersionToDomain(v twhelp.Version) domain.TWVersion {
	return domain.TWVersion(v)
}

func (t *TWHelpHTTP) convertServerToDomain(s twhelp.Server) domain.TWServer {
	return domain.TWServer(s)
}

func (t *TWHelpHTTP) convertTribeToDomain(tr twhelp.Tribe) domain.Tribe {
	return domain.Tribe(tr)
}

func (t *TWHelpHTTP) convertTribeMetaToDomain(tr twhelp.TribeMeta) domain.TribeMeta {
	return domain.TribeMeta(tr)
}

func (t *TWHelpHTTP) convertNullTribeMetaToDomain(tr twhelp.NullTribeMeta) domain.NullTribeMeta {
	return domain.NullTribeMeta{
		Tribe: t.convertTribeMetaToDomain(tr.Tribe),
		Valid: tr.Valid,
	}
}

func (t *TWHelpHTTP) convertPlayerMetaToDomain(p twhelp.PlayerMeta) domain.PlayerMeta {
	return domain.PlayerMeta{
		ID:         p.ID,
		Name:       p.Name,
		ProfileURL: p.ProfileURL,
		Tribe:      t.convertNullTribeMetaToDomain(p.Tribe),
	}
}

func (t *TWHelpHTTP) convertNullPlayerMetaToDomain(p twhelp.NullPlayerMeta) domain.NullPlayerMeta {
	return domain.NullPlayerMeta{
		Player: t.convertPlayerMetaToDomain(p.Player),
		Valid:  p.Valid,
	}
}

func (t *TWHelpHTTP) convertVillageToDomain(v twhelp.Village) domain.Village {
	return domain.Village{
		ID:         v.ID,
		FullName:   v.FullName,
		ProfileURL: v.ProfileURL,
		Points:     v.Points,
		X:          v.X,
		Y:          v.Y,
		Player:     t.convertNullPlayerMetaToDomain(v.Player),
	}
}

func (t *TWHelpHTTP) convertVillageMetaToDomain(v twhelp.VillageMeta) domain.VillageMeta {
	return domain.VillageMeta{
		ID:         v.ID,
		FullName:   v.FullName,
		ProfileURL: v.ProfileURL,
		Player:     t.convertNullPlayerMetaToDomain(v.Player),
	}
}

func (t *TWHelpHTTP) convertEnnoblementToDomain(e twhelp.Ennoblement) domain.Ennoblement {
	return domain.Ennoblement{
		ID:        e.ID,
		Village:   t.convertVillageMetaToDomain(e.Village),
		NewOwner:  t.convertNullPlayerMetaToDomain(e.NewOwner),
		CreatedAt: e.CreatedAt,
	}
}