core/internal/adapter/http_tw.go

package adapter

import (
	"context"
	"fmt"

	"gitea.dwysokinski.me/twhelp/corev3/internal/domain"
	"gitea.dwysokinski.me/twhelp/corev3/internal/tw"
)

type TWHTTP struct {
	client *tw.Client
}

func NewTWHTTP(client *tw.Client) *TWHTTP {
	return &TWHTTP{client: client}
}

func (t *TWHTTP) GetOpenServers(ctx context.Context, baseURL string) (domain.BaseServers, error) {
	servers, err := t.client.GetOpenServers(ctx, baseURL)
	if err != nil {
		return nil, err
	}

	return t.convertServersToDomain(servers)
}

func (t *TWHTTP) convertServersToDomain(servers []tw.Server) (domain.BaseServers, error) {
	res := make(domain.BaseServers, 0, len(servers))

	for _, s := range servers {
		converted, err := domain.NewBaseServer(s.Key, s.URL, true)
		if err != nil {
			return nil, fmt.Errorf("couldn't construct domain.BaseServer: %w", err)
		}

		res = append(res, converted)
	}

	return res, nil
}

func (t *TWHTTP) GetServerConfig(ctx context.Context, baseURL string) (domain.ServerConfig, error) {
	cfg, err := t.client.GetServerConfig(ctx, baseURL)
	if err != nil {
		return domain.ServerConfig{}, err
	}

	res, err := domain.NewServerConfig(
		cfg.Speed,
		cfg.UnitSpeed,
		cfg.Moral,
		domain.ServerConfigBuild(cfg.Build),
		domain.ServerConfigMisc(cfg.Misc),
		domain.ServerConfigCommands(cfg.Commands),
		domain.ServerConfigNewbie(cfg.Newbie),
		domain.ServerConfigGame{
			BuildtimeFormula:   cfg.Game.BuildtimeFormula,
			Knight:             cfg.Game.Knight,
			KnightNewItems:     cfg.Game.KnightNewItems.Int(),
			Archer:             cfg.Game.Archer,
			Tech:               cfg.Game.Tech,
			FarmLimit:          cfg.Game.FarmLimit,
			Church:             cfg.Game.Church,
			Watchtower:         cfg.Game.Watchtower,
			Stronghold:         cfg.Game.Stronghold,
			FakeLimit:          cfg.Game.FakeLimit,
			BarbarianRise:      cfg.Game.BarbarianRise,
			BarbarianShrink:    cfg.Game.BarbarianShrink,
			BarbarianMaxPoints: cfg.Game.BarbarianMaxPoints,
			Scavenging:         cfg.Game.Scavenging,
			Hauls:              cfg.Game.Hauls,
			HaulsBase:          cfg.Game.HaulsBase,
			HaulsMax:           cfg.Game.HaulsMax,
			BaseProduction:     cfg.Game.BaseProduction,
			Event:              cfg.Game.Event,
			SuppressEvents:     cfg.Game.SuppressEvents,
		},
		domain.ServerConfigBuildings(cfg.Buildings),
		domain.ServerConfigSnob(cfg.Snob),
		domain.ServerConfigAlly(cfg.Ally),
		domain.ServerConfigCoord(cfg.Coord),
		domain.ServerConfigSitter(cfg.Sitter),
		domain.ServerConfigSleep(cfg.Sleep),
		domain.ServerConfigNight(cfg.Night),
		domain.ServerConfigWin(cfg.Win),
	)
	if err != nil {
		return domain.ServerConfig{}, fmt.Errorf("couldn't construct domain.ServerConfig: %w", err)
	}

	return res, nil
}

func (t *TWHTTP) GetUnitInfo(ctx context.Context, baseURL string) (domain.UnitInfo, error) {
	info, err := t.client.GetUnitInfo(ctx, baseURL)
	if err != nil {
		return domain.UnitInfo{}, err
	}

	res, err := domain.NewUnitInfo(
		domain.Unit(info.Spear),
		domain.Unit(info.Sword),
		domain.Unit(info.Axe),
		domain.Unit(info.Archer),
		domain.Unit(info.Spy),
		domain.Unit(info.Light),
		domain.Unit(info.Marcher),
		domain.Unit(info.Heavy),
		domain.Unit(info.Ram),
		domain.Unit(info.Catapult),
		domain.Unit(info.Knight),
		domain.Unit(info.Snob),
		domain.Unit(info.Militia),
	)
	if err != nil {
		return domain.UnitInfo{}, fmt.Errorf("couldn't construct domain.UnitInfo: %w", err)
	}

	return res, nil
}

func (t *TWHTTP) GetBuildingInfo(ctx context.Context, baseURL string) (domain.BuildingInfo, error) {
	info, err := t.client.GetBuildingInfo(ctx, baseURL)
	if err != nil {
		return domain.BuildingInfo{}, err
	}

	res, err := domain.NewBuildingInfo(
		domain.Building(info.Main),
		domain.Building(info.Barracks),
		domain.Building(info.Stable),
		domain.Building(info.Garage),
		domain.Building(info.Watchtower),
		domain.Building(info.Snob),
		domain.Building(info.Smith),
		domain.Building(info.Place),
		domain.Building(info.Statue),
		domain.Building(info.Market),
		domain.Building(info.Wood),
		domain.Building(info.Stone),
		domain.Building(info.Iron),
		domain.Building(info.Farm),
		domain.Building(info.Storage),
		domain.Building(info.Hide),
		domain.Building(info.Wall),
	)
	if err != nil {
		return domain.BuildingInfo{}, fmt.Errorf("couldn't construct domain.BuildingInfo: %w", err)
	}

	return res, nil
}