package answer

import (
	"context"
	"database/sql"
	"encoding/json"
	"gitea.pena/SQuiz/common/dal/sqlcgen"
	"gitea.pena/SQuiz/common/model"
)

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

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

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

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

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

	for _, ans := range answers {
		if ans.Utm == nil {
			ans.Utm = make(model.UTMSavingMap)
		}
		utmJSON, err := json.Marshal(ans.Utm)
		if err != nil {
			return nil, []error{err}
		}

		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,
			Utm:         utmJSON,
			Version:     ans.Version,
		}

		row, err := r.queries.InsertAnswers(ctx, params)
		createdAnswer := model.Answer{
			Id:          uint64(row.ID),
			Content:     row.Content.String,
			QuizId:      uint64(row.QuizID),
			QuestionId:  uint64(row.QuestionID),
			Fingerprint: row.Fingerprint.String,
			Session:     row.Session.String,
			Result:      row.Result.Bool,
			New:         row.New.Bool,
			Email:       row.Email,
			DeviceType:  row.DeviceType,
			Device:      row.Device,
			OS:          row.Os,
			Browser:     row.Browser,
			IP:          row.Ip,
			Start:       row.Start,
			Version:     row.Version,
		}

		if err != nil {
			errs = append(errs, err)
		} else {
			createdAnswers = append(createdAnswers, createdAnswer)
		}
	}

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

	return createdAnswers, errs
}

// 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 {
		resultAnswer := model.ResultAnswer{
			Content:    row.Content.String,
			CreatedAt:  row.CreatedAt.Time,
			QuestionID: uint64(row.QuestionID),
			AnswerID:   uint64(row.ID),
			Version:    row.Version,
		}

		results = append(results, resultAnswer)
	}

	return results, nil
}