// Package backendservers implements CRUD against the backend_servers
// table — die konkreten Upstream-Server pro Backend-Pool. Schema in
// migration 0016_backend_servers.sql.
package backendservers

import (
	"context"
	"errors"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgxpool"

	"git.netcell-it.de/projekte/edgeguard-native/internal/models"
)

var ErrNotFound = errors.New("backend server not found")

type Repo struct {
	Pool *pgxpool.Pool
}

func New(pool *pgxpool.Pool) *Repo { return &Repo{Pool: pool} }

const baseSelect = `
SELECT id, backend_id, name, address, port, weight, backup, active,
       created_at, updated_at
FROM backend_servers
`

// ListByBackend liefert alle Server eines Pools. Sortierung: backup
// am Ende (HAProxy bedient sie nur wenn primaries down sind, in der
// UI sollen sie auch optisch unten stehen), dann nach name.
func (r *Repo) ListByBackend(ctx context.Context, backendID int64) ([]models.BackendServer, error) {
	rows, err := r.Pool.Query(ctx,
		baseSelect+" WHERE backend_id = $1 ORDER BY backup ASC, name ASC", backendID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	out := make([]models.BackendServer, 0, 4)
	for rows.Next() {
		s, err := scan(rows)
		if err != nil {
			return nil, err
		}
		out = append(out, *s)
	}
	return out, rows.Err()
}

// ListAll gibt sämtliche Server zurück — wird vom HAProxy-Renderer
// genutzt, damit der View in einem einzigen Query alle Pools füllt.
func (r *Repo) ListAll(ctx context.Context) ([]models.BackendServer, error) {
	rows, err := r.Pool.Query(ctx,
		baseSelect+" ORDER BY backend_id ASC, backup ASC, name ASC")
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	out := make([]models.BackendServer, 0, 16)
	for rows.Next() {
		s, err := scan(rows)
		if err != nil {
			return nil, err
		}
		out = append(out, *s)
	}
	return out, rows.Err()
}

func (r *Repo) Get(ctx context.Context, id int64) (*models.BackendServer, error) {
	row := r.Pool.QueryRow(ctx, baseSelect+" WHERE id = $1", id)
	s, err := scan(row)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return nil, ErrNotFound
		}
		return nil, err
	}
	return s, nil
}

func (r *Repo) Create(ctx context.Context, s models.BackendServer) (*models.BackendServer, error) {
	if s.Weight == 0 {
		s.Weight = 100
	}
	row := r.Pool.QueryRow(ctx, `
INSERT INTO backend_servers (backend_id, name, address, port, weight, backup, active)
VALUES ($1, $2, $3, $4, $5, $6, $7)
RETURNING id, backend_id, name, address, port, weight, backup, active,
          created_at, updated_at`,
		s.BackendID, s.Name, s.Address, s.Port, s.Weight, s.Backup, s.Active)
	return scan(row)
}

func (r *Repo) Update(ctx context.Context, id int64, s models.BackendServer) (*models.BackendServer, error) {
	if s.Weight == 0 {
		s.Weight = 100
	}
	row := r.Pool.QueryRow(ctx, `
UPDATE backend_servers SET
   name = $1,
   address = $2,
   port = $3,
   weight = $4,
   backup = $5,
   active = $6,
   updated_at = NOW()
WHERE id = $7
RETURNING id, backend_id, name, address, port, weight, backup, active,
          created_at, updated_at`,
		s.Name, s.Address, s.Port, s.Weight, s.Backup, s.Active, id)
	out, err := scan(row)
	if err != nil {
		if errors.Is(err, pgx.ErrNoRows) {
			return nil, ErrNotFound
		}
		return nil, err
	}
	return out, nil
}

func (r *Repo) Delete(ctx context.Context, id int64) error {
	tag, err := r.Pool.Exec(ctx, `DELETE FROM backend_servers WHERE id = $1`, id)
	if err != nil {
		return err
	}
	if tag.RowsAffected() == 0 {
		return ErrNotFound
	}
	return nil
}

func scan(row interface{ Scan(...any) error }) (*models.BackendServer, error) {
	var s models.BackendServer
	if err := row.Scan(
		&s.ID, &s.BackendID, &s.Name, &s.Address, &s.Port,
		&s.Weight, &s.Backup, &s.Active,
		&s.CreatedAt, &s.UpdatedAt,
	); err != nil {
		return nil, err
	}
	return &s, nil
}