package main

import (
	"context"

	"atlas9.dev/c/core"
	"atlas9.dev/c/core/dbi"
	"atlas9.dev/c/core/iam"
)

type SqliteTenantStore struct {
	db dbi.DBI
}

var _ iam.TenantStore = (*SqliteTenantStore)(nil)

func NewSqliteTenantStore(db dbi.DBI) *SqliteTenantStore {
	return &SqliteTenantStore{db: db}
}

func (s *SqliteTenantStore) Save(ctx context.Context, t *iam.Tenant) (bool, error) {
	if t.ID.IsZero() {
		t.ID = core.NewID()
	}

	res, err := s.db.Exec(ctx, `
		INSERT INTO tenants (id, name, type) VALUES ($1, $2, $3)
		ON CONFLICT (id) DO NOTHING
	`, t.ID, t.Name, t.Type)
	if err != nil {
		return false, err
	}

	n, err := res.RowsAffected()
	if err != nil {
		return false, err
	}
	created := n > 0

	if !created {
		existing, err := s.Get(ctx, t.ID)
		if err != nil {
			return false, err
		}
		*t = *existing
	}
	return created, nil
}

func (s *SqliteTenantStore) Get(ctx context.Context, id core.ID) (*iam.Tenant, error) {
	var t iam.Tenant
	err := dbi.Get(ctx, s.db, &t, `SELECT id, name, type FROM tenants WHERE id = $1`, id)
	return &t, err
}

func (s *SqliteTenantStore) Delete(ctx context.Context, id core.ID) error {
	_, err := s.db.Exec(ctx, `DELETE FROM tenants WHERE id = $1`, id)
	return err
}

func (s *SqliteTenantStore) List(ctx context.Context, page core.PageReq) (core.Page[iam.Tenant], error) {
	limit := page.Limit
	if limit <= 0 {
		limit = 100
	}
	rows, err := s.db.Query(ctx, `
		SELECT id, name, type FROM tenants
		WHERE id > $1 ORDER BY id LIMIT $2
	`, page.Cursor, limit)
	if err != nil {
		return core.Page[iam.Tenant]{}, err
	}
	defer rows.Close()

	var items []iam.Tenant
	for rows.Next() {
		var t iam.Tenant
		if err := rows.Scan(&t.ID, &t.Name, &t.Type); err != nil {
			return core.Page[iam.Tenant]{}, err
		}
		items = append(items, t)
	}
	if err := rows.Err(); err != nil {
		return core.Page[iam.Tenant]{}, err
	}
	var cursor string
	if len(items) == limit {
		cursor = items[limit-1].ID.String()
	}
	return core.Page[iam.Tenant]{Items: items, Cursor: cursor}, nil
}