package answer

import (
	"context"
	"database/sql"
	"fmt"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/dal/sqlcgen"
	"penahub.gitlab.yandexcloud.net/backend/quiz/common.git/model"
)

type Deps struct {
	Queries     *sqlcgen.Queries
	Pool        *sql.DB
	AnswerMinio *dal.StorerAnswer
}

type AnswerRepository struct {
	queries     *sqlcgen.Queries
	pool        *sql.DB
	answerMinio *dal.StorerAnswer
}

func NewAnswerRepository(deps Deps) *AnswerRepository {
	return &AnswerRepository{
		queries:     deps.Queries,
		pool:        deps.Pool,
		answerMinio: deps.AnswerMinio,
	}
}

// test +
func (r *AnswerRepository) CreateAnswers(ctx context.Context, answers []model.Answer, session, fp string, quizID uint64) ([]uint64, []error) {
	var (
		answered []uint64
		errs     []error
	)

	tx, err := r.pool.BeginTx(ctx, nil)
	if err != nil {
		return nil, []error{err}
	}

	for _, ans := range answers {
		params := sqlcgen.InsertAnswersParams{
			Content:     sql.NullString{String: ans.Content, Valid: true},
			QuizID:      int64(quizID),
			QuestionID:  int64(ans.QuestionId),
			Fingerprint: sql.NullString{String: fp, Valid: true},
			Session:     sql.NullString{String: session, Valid: true},
			Result:      sql.NullBool{Bool: ans.Result, Valid: true},
			Email:       ans.Email,
			Device:      ans.Device,
			DeviceType:  ans.DeviceType,
			Ip:          ans.IP,
			Browser:     ans.Browser,
			Os:          ans.OS,
			Start:       ans.Start,
		}

		err := r.queries.InsertAnswers(ctx, params)
		if err != nil {
			errs = append(errs, err)
		} else {
			answered = append(answered, ans.QuestionId)
		}
	}

	err = tx.Commit()
	if err != nil {
		errs = append(errs, err)
		return nil, errs
	}

	return answered, nil
}

// test +
func (r *AnswerRepository) GetAllAnswersByQuizID(ctx context.Context, session string) ([]model.ResultAnswer, error) {
	var results []model.ResultAnswer

	rows, err := r.queries.GetAllAnswersByQuizID(ctx, sql.NullString{String: session, Valid: true})
	if err != nil {
		return nil, err
	}

	for _, row := range rows {

		if row.Questiontype.(string) == model.TypeFile {
			fileURL, err := r.answerMinio.GetAnswerURL(ctx, row.Qid.UUID.String(), row.QuestionID, row.Content.String)
			if err != nil {
				fmt.Println("GetAnswerURL dal answer minio answer", err)
				return nil, err
			}
			row.Content = sql.NullString{String: fmt.Sprintf("%s|%s", fileURL, row.Content.String), Valid: true}
		}

		resultAnswer := model.ResultAnswer{
			Content:    row.Content.String,
			CreatedAt:  row.CreatedAt.Time,
			QuestionID: uint64(row.QuestionID),
			AnswerID:   uint64(row.ID),
		}

		results = append(results, resultAnswer)
	}

	return results, nil
}