package pg

import (
	"context"
	"fmt"
	"time"

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

	"git.loyso.art/frx/devsim/internal/entities"
	"git.loyso.art/frx/devsim/internal/store/pg/queries"
)

func Dial(ctx context.Context, addr string) (*repository, error) {
	config, err := pgxpool.ParseConfig(addr)
	if err != nil {
		return nil, fmt.Errorf("parsing config: %w", err)
	}

	pool, err := pgxpool.NewWithConfig(ctx, config)
	if err != nil {
		return nil, fmt.Errorf("connecting to db: %w", err)
	}

	return &repository{db: pool}, nil
}

type repository struct {
	db *pgxpool.Pool
}

func (r *repository) StatsRepository() statsRepository {
	return statsRepository{
		db: r.db,
	}
}

func (r *repository) Close() error {
	r.db.Close()
	return nil
}

type statsRepository struct {
	db *pgxpool.Pool
}

type deviceStatsDB struct {
	UpdatedAt       time.Time
	DeviceID        string
	IncomingTraffic int
	OutgoingTraffic int
	IncomingRPS     int
	ReadRPS         int
	WriteRPS        int
}

func (s deviceStatsDB) asDomain() entities.DeviceStatistics {
	return entities.DeviceStatistics{
		ID:                   entities.DeviceID(s.DeviceID),
		IncomingTrafficBytes: s.IncomingTraffic,
		OutgoingTrafficBytes: s.OutgoingTraffic,
		IncomingRPS:          s.IncomingRPS,
		ReadRPS:              s.ReadRPS,
		WriteRPS:             s.WriteRPS,
		UpdatedAt:            s.UpdatedAt,
	}
}

func (r statsRepository) Upsert(ctx context.Context, stats entities.DeviceStatistics) error {
	err := queries.New(r.db).UpsertDeviceMetrics(ctx, queries.UpsertDeviceMetricsParams{
		DeviceID:   string(stats.ID),
		IncTraffic: int32(stats.IncomingTrafficBytes),
		OutTraffic: int32(stats.OutgoingTrafficBytes),
		IncRps:     int32(stats.IncomingRPS),
		WriteRps:   int32(stats.WriteRPS),
		ReadRps:    int32(stats.ReadRPS),
	})
	if err != nil {
		return fmt.Errorf("upserting device metrics: %w", err)
	}

	return nil
}

func (r statsRepository) List(ctx context.Context) (out []entities.DeviceStatistics, err error) {
	stats, err := queries.New(r.db).ListDeviceStats(ctx)
	if err != nil {
		return nil, fmt.Errorf("listing device stats: %w", err)
	}

	out = make([]entities.DeviceStatistics, len(stats))

	for i, stat := range stats {
		out[i] = entities.DeviceStatistics{
			IncomingTrafficBytes: int(stat.IncTraffic),
			OutgoingTrafficBytes: int(stat.OutTraffic),
			IncomingRPS:          int(stat.IncRps),
			WriteRPS:             int(stat.WriteRps),
			ReadRPS:              int(stat.ReadRps),
			UpdatedAt:            stat.UpdatedAt.Time,
		}
	}

	return out, nil
}