package dal

import (
	"context"
	"database/sql"
	_ "embed"
	"errors"
	"github.com/golang-migrate/migrate/v4"
	"github.com/golang-migrate/migrate/v4/database/postgres"
	_ "github.com/golang-migrate/migrate/v4/source/file"
	_ "github.com/lib/pq"
	"github.com/minio/minio-go/v7"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal/sqlcgen"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/repository/account"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/repository/answer"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/repository/question"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/repository/quiz"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/repository/result"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/repository/statistics"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/repository/workers"
	"penahub.gitlab.yandexcloud.net/backend/quiz/core.git/clients/auth"
	"time"
)

var errNextDeclined = errors.New("next is declined")

type DAL struct {
	conn           *sql.DB
	authClient     *auth.AuthClient
	queries        *sqlcgen.Queries
	AccountRepo    *account.AccountRepository
	AnswerRepo     *answer.AnswerRepository
	QuestionRepo   *question.QuestionRepository
	QuizRepo       *quiz.QuizRepository
	ResultRepo     *result.ResultRepository
	WorkerRepo     *workers.WorkerRepository
	StatisticsRepo *statistics.StatisticsRepository
}

func New(ctx context.Context, cred string, authClient *auth.AuthClient, minioClient *minio.Client) (*DAL, error) {
	pool, err := sql.Open("postgres", cred)
	if err != nil {
		return nil, err
	}

	timeoutCtx, cancel := context.WithTimeout(ctx, time.Second)
	defer cancel()

	if err := pool.PingContext(timeoutCtx); err != nil {
		return nil, err
	}

	queries := sqlcgen.New(pool)

	accountRepo := account.NewAccountRepository(account.Deps{
		Queries:    queries,
		AuthClient: authClient,
		Pool:       pool,
	})

	storerAnswer := &answer.StorerAnswer{}

	if minioClient != nil {
		storerAnswer, err = answer.NewAnswerMinio(ctx, minioClient)
		if err != nil {
			return nil, err
		}
	}

	answerRepo := answer.NewAnswerRepository(answer.Deps{
		Queries:     queries,
		Pool:        pool,
		AnswerMinio: storerAnswer,
	})

	questionRepo := question.NewQuestionRepository(question.Deps{
		Queries: queries,
		Pool:    pool,
	})

	quizRepo := quiz.NewQuizRepository(quiz.Deps{
		Queries: queries,
		Pool:    pool,
	})

	resultRepo := result.NewResultRepository(result.Deps{
		Queries: queries,
		Pool:    pool,
	})

	workerRepo := workers.NewWorkerRepository(workers.Deps{
		Queries: queries,
	})

	statisticsRepo := statistics.NewStatisticsRepo(statistics.Deps{
		Queries: queries,
		Pool:    pool,
	})

	return &DAL{
		conn:           pool,
		authClient:     authClient,
		queries:        queries,
		AccountRepo:    accountRepo,
		AnswerRepo:     answerRepo,
		QuestionRepo:   questionRepo,
		QuizRepo:       quizRepo,
		ResultRepo:     resultRepo,
		WorkerRepo:     workerRepo,
		StatisticsRepo: statisticsRepo,
	}, nil
}

func (d *DAL) Close() {
	d.conn.Close()
}

func (d *DAL) Init() error {
	driver, err := postgres.WithInstance(d.conn, &postgres.Config{})
	if err != nil {
		return err
	}

	m, err := migrate.NewWithDatabaseInstance(
		"file://schema",
		"postgres", driver,
	)
	if err != nil {
		return err
	}

	if err := m.Up(); err != nil && err != migrate.ErrNoChange {
		return err
	}
	return nil
}