package storage

import "context"

type AdminPartner struct {
	ID        int64  `json:"id"`
	Name      string `json:"name"`
	URL       string `json:"url"`
	LogoID    *int64 `json:"logo_id"`
	Logo      string `json:"logo,omitempty"`
	Sort      int    `json:"sort"`
	Published bool   `json:"published"`
}

func (s *Storage) AdminPartners(ctx context.Context) ([]AdminPartner, error) {
	rows, err := s.pool.Query(ctx, `
		SELECT p.id, p.name, p.url, p.logo_id, COALESCE(m.path, ''), p.sort, p.published
		FROM partners p
		LEFT JOIN media m ON m.id = p.logo_id
		ORDER BY p.sort, p.name`)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var out []AdminPartner
	for rows.Next() {
		var p AdminPartner
		if err := rows.Scan(&p.ID, &p.Name, &p.URL, &p.LogoID, &p.Logo, &p.Sort, &p.Published); err != nil {
			return nil, err
		}
		out = append(out, p)
	}
	return out, rows.Err()
}

type PartnerInput struct {
	Name      string
	URL       string
	LogoID    *int64
	Sort      int
	Published bool
}

func (s *Storage) AdminCreatePartner(ctx context.Context, in PartnerInput) (int64, error) {
	var id int64
	err := s.pool.QueryRow(ctx, `
		INSERT INTO partners (name, url, logo_id, sort, published)
		VALUES ($1,$2,$3,$4,$5)
		RETURNING id`,
		in.Name, in.URL, in.LogoID, in.Sort, in.Published).Scan(&id)
	return id, wrapConflict(err)
}

func (s *Storage) AdminUpdatePartner(ctx context.Context, id int64, in PartnerInput) error {
	tag, err := s.pool.Exec(ctx, `
		UPDATE partners SET name=$2, url=$3, logo_id=$4, sort=$5, published=$6
		WHERE id=$1`,
		id, in.Name, in.URL, in.LogoID, in.Sort, in.Published)
	if err != nil {
		return wrapConflict(err)
	}
	if tag.RowsAffected() == 0 {
		return ErrNotFound
	}
	return nil
}

func (s *Storage) AdminDeletePartner(ctx context.Context, id int64) error {
	tag, err := s.pool.Exec(ctx, `DELETE FROM partners WHERE id=$1`, id)
	if err != nil {
		return err
	}
	if tag.RowsAffected() == 0 {
		return ErrNotFound
	}
	return nil
}