package main

import (
	"context"
	_ "embed"
	"fmt"

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

//go:embed sql/schema.sql
var sqlSchema string

//go:embed sql/views.sql
var sqlViews string

type PostgresClient struct {
	//TODO move context out of client
	Ctx  context.Context
	Pool *pgxpool.Pool
}

func (db *PostgresClient) CreateOrReplaceSchema() error {
	_, err := db.Pool.Exec(db.Ctx, sqlSchema)
	return err
}

func (db *PostgresClient) CreateOrReplaceViews() error {
	_, err := db.Pool.Exec(db.Ctx, sqlViews)
	return err
}

// InsertMembres inserts a slice of Membre into a database, returning the amount inserted and any error encountered
func (d *PostgresClient) InsertMembres(membres ...Membre) (inserted int64, err error) {
	select {
	case <-d.Ctx.Done():
		return inserted, fmt.Errorf("PostgresClient.Ctx closed: %s", d.Ctx.Err())
	default:
		tx, err := d.Pool.Begin(d.Ctx)
		if err != nil {
			return inserted, err
		}
		defer tx.Rollback(d.Ctx)

		for i, membre := range membres {
			if membre.ID == "" {
				return inserted, fmt.Errorf("insertion ligne %d: membre requiert numéro étudiant valide", i)
			}

			result, err := tx.Exec(d.Ctx, `
INSERT INTO membres
  (id, last_name, first_name, prefered_name, programme_id)
VALUES
  ($1, $2, $3, $4, $5)
ON CONFLICT (id) DO NOTHING;`,
				membre.ID,
				membre.LastName,
				membre.FirstName,
				membre.PreferedName,
				membre.ProgrammeID,
			)
			if err != nil {
				return 0, err
			}

			inserted += result.RowsAffected()
		}

		if err = tx.Commit(d.Ctx); err != nil {
			return 0, err
		}

		return inserted, err
	}
}

func (d *PostgresClient) InsertProgrammes(programmes ...Programme) (inserted int64, err error) {
	select {
	case <-d.Ctx.Done():
		return inserted, fmt.Errorf("PostgresClient.Ctx closed: %s", d.Ctx.Err())
	default:
		tx, err := d.Pool.Begin(d.Ctx)
		if err != nil {
			return inserted, err
		}
		defer tx.Rollback(d.Ctx)

		for _, programme := range programmes {
			if programme.ID == "" {
				return 0, fmt.Errorf("Cannot insert programme with no programme_id")
			}

			result, err := tx.Exec(d.Ctx, `
INSERT INTO programmes
(id, name)
VALUES ($1, $2) ON CONFLICT DO NOTHING;`,
				programme.ID,
				programme.Name)
			if err != nil {
				return 0, err
			}

			inserted += result.RowsAffected()
		}

		if err := tx.Commit(d.Ctx); err != nil {
			return inserted, err
		}

		return inserted, err
	}
}

func (d *PostgresClient) GetMembre(membreID string) (membre Membre, err error) {
	select {
	case <-d.Ctx.Done():
		err = fmt.Errorf("PostgresClient.Ctx closed: %s", d.Ctx.Err())
		return
	default:
		if err = d.Pool.QueryRow(d.Ctx, `
SELECT
  "membres".id,
  "membres".last_name,
  "membres".first_name,
  "membres".prefered_name,
  "membres".programme_id
FROM
  "membres"
WHERE
  "membres".id = $1
LIMIT
  1;
`, membreID).Scan(
			&membre.ID,
			&membre.LastName,
			&membre.FirstName,
			&membre.PreferedName,
			&membre.ProgrammeID,
		); err != nil {
			return
		}

		if membre.ID == "" {
			return membre, fmt.Errorf("Aucun membre trouvé avec numéro '%s'", membre.ID)
		}

		return membre, nil
	}
}

/*
func (d *PostgresClient) UpdateMembreName(membreID, newName string) (int64, error) {
	result, err := d.Pool.Exec("UPDATE membres SET prefered_name = $1 WHERE id = $2;", newName, membreID)
	if err != nil {
		return 0, err
	}

	rows, err := result.RowsAffected()
	if err != nil {
		return rows, err
	}

	return rows, nil
}
*/

func (d *PostgresClient) GetMembres(limit int) (membres []Membre, err error) {
	select {
	case <-d.Ctx.Done():
		return nil, fmt.Errorf("PostgresClient.Ctx closed: %s", d.Ctx.Err())
	default:
		rows, err := d.Pool.Query(d.Ctx, `
SELECT
  "membres".id,
  "membres".last_name,
  "membres".first_name,
  "membres".prefered_name,
  "membres".programme_id
FROM
  "membres"
ORDER BY
  "membres".id
LIMIT
  $1;
`, limit)
		if err != nil {
			return nil, err
		}
		defer rows.Close()

		for rows.Next() {
			var membre Membre

			if err = rows.Scan(
				&membre.ID,
				&membre.LastName,
				&membre.FirstName,
				&membre.PreferedName,
				&membre.ProgrammeID,
			); err != nil {
				return nil, err
			}

			membres = append(membres, membre)
		}
		if rows.Err() != nil {
			return membres, rows.Err()
		}

		return membres, nil
	}
}

func (d *PostgresClient) GetProgrammes(limit int) (programmes []Programme, err error) {
	select {
	case <-d.Ctx.Done():
		return nil, fmt.Errorf("PostgresClient.Ctx closed: %s", d.Ctx.Err())
	default:
		rows, err := d.Pool.Query(d.Ctx, `
SELECT
  "programmes".id,
  "programmes".name
FROM
  "programmes"
ORDER BY
  "programmes".id
LIMIT
  $1;
`, limit)
		if err != nil {
			return nil, err
		}
		defer rows.Close()

		for rows.Next() {
			var programme Programme

			if err = rows.Scan(
				&programme.ID,
				&programme.Name,
			); err != nil {
				return nil, err
			}

			programmes = append(programmes, programme)
		}
		if rows.Err() != nil {
			return programmes, rows.Err()
		}

		return programmes, nil
	}
}

func (d *PostgresClient) UpdateMembrePreferedName(membreID string, name string) (err error) {
	select {
	case <-d.Ctx.Done():
		return fmt.Errorf("PostgresClient.Ctx closed: %s", d.Ctx.Err())
	default:
		if !IsMembreID(membreID) {
			return fmt.Errorf("Numéro étudiant '%s' invalide", membreID)
		}

		_, err = d.Pool.Exec(d.Ctx, `
UPDATE
  "membres"
SET
  prefered_name = $1
WHERE
  "membres".id = $2;
`, name, membreID)
	}
	return
}