core-old/internal/tw/client.go

package tw

import (
	"context"
	"encoding/csv"
	"encoding/xml"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/elliotchance/phpserialize"
)

const (
	defaultUserAgent = "tribalwarshelp/development"
	defaultTimeout   = 10 * time.Second

	fieldsPerRecordPlayer      = 6
	fieldsPerRecordTribe       = 8
	fieldsPerRecordVillage     = 7
	fieldsPerRecordOD          = 3
	fieldsPerRecordEnnoblement = 7

	endpointPlayers               = "/map/player.txt"
	endpointTribes                = "/map/ally.txt"
	endpointVillages              = "/map/village.txt"
	endpointPlayersODA            = "/map/kill_att.txt"
	endpointPlayersODD            = "/map/kill_def.txt"
	endpointPlayersODS            = "/map/kill_sup.txt"
	endpointPlayersOD             = "/map/kill_all.txt"
	endpointTribesODA             = "/map/kill_att_tribe.txt"
	endpointTribesODD             = "/map/kill_def_tribe.txt"
	endpointTribesOD              = "/map/kill_all_tribe.txt"
	endpointMapEnnoblements       = "/map/conquer_extended.txt"
	endpointInterface             = "/interface.php"
	endpointConfig                = endpointInterface + "?func=get_config"
	endpointUnitInfo              = endpointInterface + "?func=get_unit_info"
	endpointBuildingInfo          = endpointInterface + "?func=get_building_info"
	endpointInterfaceEnnoblements = endpointInterface + "?func=get_conquer_extended&since=%d"
	endpointGetServers            = "/backend/get_servers.php"
	endpointPlayerProfile         = "/game.php?screen=info_player&id=%d"
	endpointTribeProfile          = "/game.php?screen=info_ally&id=%d"
	endpointVillageProfile        = "/game.php?screen=info_village&id=%d"
)

var (
	ErrInvalidServerKey = errors.New("invalid server key")
	ErrInvalidServerURL = errors.New("invalid server URL")
)

type ClientOption func(c *Client)

func WithUserAgent(ua string) ClientOption {
	return func(c *Client) {
		c.userAgent = ua
	}
}

func WithHTTPClient(hc *http.Client) ClientOption {
	return func(c *Client) {
		c.client = hc
	}
}

type Client struct {
	client    *http.Client
	userAgent string
}

func NewClient(opts ...ClientOption) *Client {
	c := &Client{
		client: &http.Client{
			Timeout: defaultTimeout,
		},
		userAgent: defaultUserAgent,
	}

	for _, opt := range opts {
		opt(c)
	}

	return c
}

type Server struct {
	Key string
	URL string
}

func (c *Client) GetOpenServers(ctx context.Context, baseURL string) ([]Server, error) {
	resp, err := c.get(ctx, buildURL(baseURL, endpointGetServers))
	if err != nil {
		return nil, fmt.Errorf("c.get: %w", err)
	}
	defer func() {
		_ = resp.Body.Close()
	}()

	b, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, fmt.Errorf("couldn't read response body: %w", err)
	}

	m, err := phpserialize.UnmarshalAssociativeArray(b)
	if err != nil {
		return nil, fmt.Errorf("phpserialize.UnmarshalAssociativeArray: %w", err)
	}

	servers := make([]Server, 0, len(m))
	for key, val := range m {
		keyStr, ok := key.(string)
		if !ok || keyStr == "" {
			return nil, fmt.Errorf("%w: %v", ErrInvalidServerKey, key)
		}

		urlStr, ok := val.(string)
		if !ok || urlStr == "" {
			return nil, fmt.Errorf("%w: %v", ErrInvalidServerURL, val)
		}

		servers = append(servers, Server{
			Key: keyStr,
			URL: urlStr,
		})
	}

	return servers, nil
}

func (c *Client) GetServerConfig(ctx context.Context, baseURL string) (ServerConfig, error) {
	var cfg ServerConfig

	if err := c.getXML(ctx, buildURL(baseURL, endpointConfig), &cfg); err != nil {
		return ServerConfig{}, fmt.Errorf("c.getXML: %w", err)
	}

	return cfg, nil
}

func (c *Client) GetBuildingInfo(ctx context.Context, baseURL string) (BuildingInfo, error) {
	var info BuildingInfo

	if err := c.getXML(ctx, buildURL(baseURL, endpointBuildingInfo), &info); err != nil {
		return BuildingInfo{}, fmt.Errorf("c.getXML: %w", err)
	}

	return info, nil
}

func (c *Client) GetUnitInfo(ctx context.Context, baseURL string) (UnitInfo, error) {
	var info UnitInfo

	if err := c.getXML(ctx, buildURL(baseURL, endpointUnitInfo), &info); err != nil {
		return UnitInfo{}, fmt.Errorf("c.getXML: %w", err)
	}

	return info, nil
}

func (c *Client) GetTribes(ctx context.Context, baseURL string) ([]Tribe, error) {
	od, err := c.getOD(ctx, baseURL, true)
	if err != nil {
		return nil, fmt.Errorf("c.getOD: %w", err)
	}

	records, err := c.getCSV(ctx, buildURL(baseURL, endpointTribes), fieldsPerRecordTribe)
	if err != nil {
		return nil, fmt.Errorf("c.getCSV: %w", err)
	}

	tribes := make([]Tribe, 0, len(records))
	for _, rec := range records {
		tribe, err := parseTribeRecord(rec, od, baseURL)
		if err != nil {
			return nil, fmt.Errorf("parseTribeRecord: %w", err)
		}

		tribes = append(tribes, tribe)
	}

	sort.SliceStable(tribes, func(i, j int) bool {
		return tribes[i].ID < tribes[j].ID
	})

	return tribes, nil
}

func (c *Client) GetPlayers(ctx context.Context, baseURL string) ([]Player, error) {
	od, err := c.getOD(ctx, baseURL, false)
	if err != nil {
		return nil, fmt.Errorf("c.getOD: %w", err)
	}

	records, err := c.getCSV(ctx, buildURL(baseURL, endpointPlayers), fieldsPerRecordPlayer)
	if err != nil {
		return nil, fmt.Errorf("c.getCSV: %w", err)
	}

	players := make([]Player, 0, len(records))
	for _, rec := range records {
		player, err := parsePlayerRecord(rec, od, baseURL)
		if err != nil {
			return nil, fmt.Errorf("parsePlayerRecord: %w", err)
		}

		players = append(players, player)
	}

	sort.SliceStable(players, func(i, j int) bool {
		return players[i].ID < players[j].ID
	})

	return players, nil
}

func (c *Client) getOD(ctx context.Context, baseURL string, tribe bool) (map[int64]OpponentsDefeated, error) {
	m := make(map[int64]OpponentsDefeated)
	urls := buildODURLs(baseURL, tribe)

	for _, u := range urls {
		if u == "" {
			continue
		}

		records, err := c.getCSV(ctx, u, fieldsPerRecordOD)
		if err != nil {
			return nil, fmt.Errorf("c.getCSV: %w", err)
		}

		for _, rec := range records {
			parsed, err := parseODRecord(rec)
			if err != nil {
				return nil, fmt.Errorf("parseODRecord: %w", err)
			}

			od := m[parsed.ID]

			switch u {
			case urls[0]:
				od.RankTotal = parsed.Rank
				od.ScoreTotal = parsed.Score
			case urls[1]:
				od.RankAtt = parsed.Rank
				od.ScoreAtt = parsed.Score
			case urls[2]:
				od.RankDef = parsed.Rank
				od.ScoreDef = parsed.Score
			case urls[3]:
				od.RankSup = parsed.Rank
				od.ScoreSup = parsed.Score
			}

			m[parsed.ID] = od
		}
	}

	return m, nil
}

func (c *Client) GetVillages(ctx context.Context, baseURL string) ([]Village, error) {
	records, err := c.getCSV(ctx, buildURL(baseURL, endpointVillages), fieldsPerRecordVillage)
	if err != nil {
		return nil, fmt.Errorf("c.getCSV: %w", err)
	}

	villages := make([]Village, 0, len(records))
	for _, rec := range records {
		village, err := parseVillageRecord(rec, baseURL)
		if err != nil {
			return nil, fmt.Errorf("parseVillageRecord: %w", err)
		}

		villages = append(villages, village)
	}

	sort.SliceStable(villages, func(i, j int) bool {
		return villages[i].ID < villages[j].ID
	})

	return villages, nil
}

func (c *Client) GetEnnoblements(ctx context.Context, baseURL string, since time.Time) ([]Ennoblement, error) {
	records, err := c.getCSV(ctx, buildEnnoblementURL(baseURL, since), fieldsPerRecordEnnoblement)
	if err != nil {
		return nil, fmt.Errorf("c.getCSV: %w", err)
	}

	// Pre-calculate slice length to reduce memory allocation
	cnt := 0
	for _, rec := range records {
		createdAt, err := parseTimestamp(rec[1])
		if err != nil {
			err = NewParseError(err, rec, "ennoblement.CreatedAt")
			return nil, err
		}

		if !createdAt.After(since) {
			continue
		}

		cnt++
	}

	ennoblements := make([]Ennoblement, 0, cnt)
	for _, rec := range records {
		ennoblement, err := parseEnnoblementRecord(rec)
		if err != nil {
			return nil, fmt.Errorf("parseEnnoblementRecord: %w", err)
		}

		if !ennoblement.CreatedAt.After(since) {
			continue
		}

		ennoblements = append(ennoblements, ennoblement)
	}

	sort.SliceStable(ennoblements, func(i, j int) bool {
		return ennoblements[i].CreatedAt.Before(ennoblements[j].CreatedAt)
	})

	return ennoblements, nil
}

func (c *Client) getXML(ctx context.Context, url string, v any) error {
	resp, err := c.get(ctx, url)
	if err != nil {
		return fmt.Errorf("c.get: %w", err)
	}
	defer func() {
		_ = resp.Body.Close()
	}()

	if err := xml.NewDecoder(resp.Body).Decode(v); err != nil {
		return fmt.Errorf("xml.Decode: %w", err)
	}

	return nil
}

func (c *Client) getCSV(ctx context.Context, url string, fieldsPerRecord int) ([][]string, error) {
	resp, err := c.get(ctx, url)
	if err != nil {
		return nil, fmt.Errorf("c.get: %w", err)
	}
	defer func() {
		_ = resp.Body.Close()
	}()

	r := csv.NewReader(resp.Body)
	r.Comma = ','
	r.FieldsPerRecord = fieldsPerRecord

	records, err := r.ReadAll()
	if err != nil {
		return nil, fmt.Errorf("CSVReader.ReadAll: %w", err)
	}

	return records, nil
}

func (c *Client) get(ctx context.Context, url string) (*http.Response, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, fmt.Errorf("http.NewRequestWithContext: %w", err)
	}

	// headers
	req.Header.Set("User-Agent", c.userAgent)

	resp, err := c.client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("client.Do: %w", err)
	}

	if resp.StatusCode != http.StatusOK {
		_, _ = io.Copy(io.Discard, resp.Body)
		_ = resp.Body.Close()
		return nil, fmt.Errorf("'%s': got non-ok HTTP status: %d", url, resp.StatusCode)
	}

	return resp, nil
}

func parseTribeRecord(record []string, od map[int64]OpponentsDefeated, baseURL string) (Tribe, error) {
	var err error
	var tribe Tribe

	tribe.ID, err = strconv.ParseInt(record[0], 10, 64)
	if err != nil {
		return Tribe{}, NewParseError(err, record, "tribe.ID")
	}

	tribe.Name, err = url.QueryUnescape(record[1])
	if err != nil {
		return Tribe{}, NewParseError(err, record, "tribe.Name")
	}

	tribe.Tag, err = url.QueryUnescape(record[2])
	if err != nil {
		return Tribe{}, NewParseError(err, record, "tribe.Tag")
	}

	tribe.NumMembers, err = strconv.ParseInt(record[3], 10, 64)
	if err != nil {
		return Tribe{}, NewParseError(err, record, "tribe.NumMembers")
	}

	tribe.NumVillages, err = strconv.ParseInt(record[4], 10, 64)
	if err != nil {
		return Tribe{}, NewParseError(err, record, "tribe.NumVillages")
	}

	tribe.Points, err = strconv.ParseInt(record[5], 10, 64)
	if err != nil {
		return Tribe{}, NewParseError(err, record, "tribe.Points")
	}

	tribe.AllPoints, err = strconv.ParseInt(record[6], 10, 64)
	if err != nil {
		return Tribe{}, NewParseError(err, record, "tribe.AllPoints")
	}

	tribe.Rank, err = strconv.ParseInt(record[7], 10, 64)
	if err != nil {
		return Tribe{}, NewParseError(err, record, "tribe.Rank")
	}

	tribe.OpponentsDefeated = od[tribe.ID]
	tribe.ProfileURL = buildURL(baseURL, fmt.Sprintf(endpointTribeProfile, tribe.ID))

	return tribe, nil
}

func parsePlayerRecord(record []string, od map[int64]OpponentsDefeated, baseURL string) (Player, error) {
	var err error
	var player Player

	player.ID, err = strconv.ParseInt(record[0], 10, 64)
	if err != nil {
		return Player{}, NewParseError(err, record, "player.ID")
	}

	player.Name, err = url.QueryUnescape(record[1])
	if err != nil {
		return Player{}, NewParseError(err, record, "player.Name")
	}

	player.TribeID, err = strconv.ParseInt(record[2], 10, 64)
	if err != nil {
		return Player{}, NewParseError(err, record, "player.TribeID")
	}

	player.NumVillages, err = strconv.ParseInt(record[3], 10, 64)
	if err != nil {
		return Player{}, NewParseError(err, record, "player.NumVillages")
	}

	player.Points, err = strconv.ParseInt(record[4], 10, 64)
	if err != nil {
		return Player{}, NewParseError(err, record, "player.Points")
	}

	player.Rank, err = strconv.ParseInt(record[5], 10, 64)
	if err != nil {
		return Player{}, NewParseError(err, record, "player.Rank")
	}

	player.OpponentsDefeated = od[player.ID]
	player.ProfileURL = buildURL(baseURL, fmt.Sprintf(endpointPlayerProfile, player.ID))

	return player, nil
}

func parseVillageRecord(record []string, baseURL string) (Village, error) {
	var err error
	var village Village

	village.ID, err = strconv.ParseInt(record[0], 10, 64)
	if err != nil {
		return Village{}, NewParseError(err, record, "village.ID")
	}

	village.Name, err = url.QueryUnescape(record[1])
	if err != nil {
		return Village{}, NewParseError(err, record, "village.Name")
	}

	village.X, err = strconv.ParseInt(record[2], 10, 64)
	if err != nil {
		return Village{}, NewParseError(err, record, "village.X")
	}

	village.Y, err = strconv.ParseInt(record[3], 10, 64)
	if err != nil {
		return Village{}, NewParseError(err, record, "village.Y")
	}

	village.PlayerID, err = strconv.ParseInt(record[4], 10, 64)
	if err != nil {
		return Village{}, NewParseError(err, record, "village.PlayerID")
	}

	village.Points, err = strconv.ParseInt(record[5], 10, 64)
	if err != nil {
		return Village{}, NewParseError(err, record, "village.Points")
	}

	village.Bonus, err = strconv.ParseInt(record[6], 10, 64)
	if err != nil {
		return Village{}, NewParseError(err, record, "village.Bonus")
	}

	village.Continent = "K" + string(record[3][0]) + string(record[2][0])
	village.ProfileURL = buildURL(baseURL, fmt.Sprintf(endpointVillageProfile, village.ID))

	return village, nil
}

type odRecord struct {
	ID    int64
	Rank  int64
	Score int64
}

func parseODRecord(record []string) (odRecord, error) {
	var err error
	var rec odRecord

	rec.Rank, err = strconv.ParseInt(record[0], 10, 64)
	if err != nil {
		return odRecord{}, NewParseError(err, record, "odRecord.Rank")
	}

	rec.ID, err = strconv.ParseInt(record[1], 10, 64)
	if err != nil {
		return odRecord{}, NewParseError(err, record, "odRecord.ID")
	}

	rec.Score, err = strconv.ParseInt(record[2], 10, 64)
	if err != nil {
		return odRecord{}, NewParseError(err, record, "odRecord.Score")
	}

	return rec, nil
}

func parseEnnoblementRecord(record []string) (Ennoblement, error) {
	var err error
	var ennoblement Ennoblement

	ennoblement.VillageID, err = strconv.ParseInt(record[0], 10, 64)
	if err != nil {
		return Ennoblement{}, NewParseError(err, record, "ennoblement.VillageID")
	}

	ennoblement.CreatedAt, err = parseTimestamp(record[1])
	if err != nil {
		return Ennoblement{}, NewParseError(err, record, "ennoblement.CreatedAt")
	}

	ennoblement.NewOwnerID, err = strconv.ParseInt(record[2], 10, 64)
	if err != nil {
		return Ennoblement{}, NewParseError(err, record, "ennoblement.NewOwnerID")
	}

	ennoblement.OldOwnerID, err = strconv.ParseInt(record[3], 10, 64)
	if err != nil {
		return Ennoblement{}, NewParseError(err, record, "ennoblement.OldOwnerID")
	}

	ennoblement.OldTribeID, err = strconv.ParseInt(record[4], 10, 64)
	if err != nil {
		return Ennoblement{}, NewParseError(err, record, "ennoblement.OldTribeID")
	}

	ennoblement.NewTribeID, err = strconv.ParseInt(record[5], 10, 64)
	if err != nil {
		return Ennoblement{}, NewParseError(err, record, "ennoblement.NewTribeID")
	}

	ennoblement.Points, err = strconv.ParseInt(record[6], 10, 64)
	if err != nil {
		return Ennoblement{}, NewParseError(err, record, "ennoblement.Points")
	}

	return ennoblement, nil
}

func parseTimestamp(s string) (time.Time, error) {
	timestamp, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		return time.Time{}, err
	}
	return time.Unix(timestamp, 0), nil
}

func buildODURLs(base string, tribe bool) [4]string {
	if tribe {
		return [4]string{
			buildURL(base, endpointTribesOD),
			buildURL(base, endpointTribesODA),
			buildURL(base, endpointTribesODD),
			"",
		}
	}
	return [4]string{
		buildURL(base, endpointPlayersOD),
		buildURL(base, endpointPlayersODA),
		buildURL(base, endpointPlayersODD),
		buildURL(base, endpointPlayersODS),
	}
}

func buildEnnoblementURL(base string, since time.Time) string {
	if since.After(time.Now().Add(-23 * time.Hour)) {
		return buildURL(base, fmt.Sprintf(endpointInterfaceEnnoblements, since.Unix()))
	}
	return buildURL(base, endpointMapEnnoblements)
}

func buildURL(base, endpoint string) string {
	if !strings.HasPrefix(base, "http") {
		return "https://" + base + endpoint
	}
	return base + endpoint
}