package quiz

import (
	"context"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"gitea.pena/SQuiz/common/dal/sqlcgen"
	"gitea.pena/SQuiz/common/model"
	"github.com/google/uuid"
	"github.com/lib/pq"

	"strings"
	"sync"
)

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

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

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

// test +
func (r *QuizRepository) CreateQuiz(ctx context.Context, record *model.Quiz) (uint64, error) {
	if record.Qid == "" {
		record.Qid = uuid.NewString()
	}

	params := sqlcgen.InsertQuizParams{
		Accountid:         record.AccountId,
		Fingerprinting:    sql.NullBool{Bool: record.Fingerprinting, Valid: true},
		Repeatable:        sql.NullBool{Bool: record.Repeatable, Valid: true},
		NotePrevented:     sql.NullBool{Bool: record.NotePrevented, Valid: true},
		MailNotifications: sql.NullBool{Bool: record.MailNotifications, Valid: true},
		UniqueAnswers:     sql.NullBool{Bool: record.UniqueAnswers, Valid: true},
		Super:             sql.NullBool{Bool: record.Super, Valid: true},
		GroupID:           sql.NullInt64{Int64: int64(record.GroupId), Valid: true},
		Name:              sql.NullString{String: record.Name, Valid: true},
		Description:       sql.NullString{String: record.Description, Valid: true},
		Config:            sql.NullString{String: record.Config, Valid: true},
		Status:            record.Status,
		LimitAnswers:      sql.NullInt32{Int32: int32(record.Limit), Valid: true},
		DueTo:             sql.NullInt32{Int32: int32(record.DueTo), Valid: true},
		TimeOfPassing:     sql.NullInt32{Int32: int32(record.TimeOfPassing), Valid: true},
		Pausable:          sql.NullBool{Bool: record.Pausable, Valid: true},
		ParentIds:         record.ParentIds,
		QuestionsCount:    sql.NullInt32{Int32: int32(record.QuestionsCount), Valid: true},
		Qid:               uuid.NullUUID{UUID: uuid.MustParse(record.Qid), Valid: true},
	}

	data, err := r.queries.InsertQuiz(ctx, params)
	if err != nil {
		return 0, err
	}

	record.Id = uint64(data.ID)
	record.CreatedAt = data.CreatedAt.Time
	record.UpdatedAt = data.UpdatedAt.Time
	record.Qid = data.Qid.UUID.String()

	return record.Id, nil
}

type GetQuizListDeps struct {
	Limit, Offset, From, To, Group uint64
	Deleted, Archived, Super       bool
	Search, Status, AccountId      string
}

// test +
// GetQuizList function for get data page from db
func (r *QuizRepository) GetQuizList(
	ctx context.Context,
	deps GetQuizListDeps) ([]model.Quiz, uint64, error) {
	query := `
	SELECT * FROM quiz
	%s
	ORDER BY created_at DESC
	LIMIT $1 OFFSET $2;
`

	queryCnt := `SELECT count(1) FROM quiz %s;`

	var (
		whereClause []string
		data        []interface{}
	)

	whereClause = append(whereClause, fmt.Sprintf(`accountid = '%s'`, deps.AccountId))
	if deps.From != 0 {
		data = append(data, deps.From)
		whereClause = append(whereClause, fmt.Sprintf("created_at >= to_timestamp($%d)", len(data)))
	}
	if deps.To != 0 {
		data = append(data, deps.To)
		whereClause = append(whereClause, fmt.Sprintf("created_at <= to_timestamp($%d)", len(data)))
	}
	if deps.Deleted {
		whereClause = append(whereClause, fmt.Sprintf("deleted = true"))
	} else {
		whereClause = append(whereClause, fmt.Sprintf("deleted = false"))
	}
	if deps.Archived {
		whereClause = append(whereClause, fmt.Sprintf("archived = true"))
	} else {
		whereClause = append(whereClause, fmt.Sprintf("archived = false"))
	}

	if deps.Super {
		whereClause = append(whereClause, fmt.Sprintf("super = true"))
	}

	if deps.Group > 0 {
		whereClause = append(whereClause, fmt.Sprintf("group_id = %d", deps.Group))
	}

	if deps.Status != "" {
		data = append(data, deps.Status)
		whereClause = append(whereClause, fmt.Sprintf("status = $%d", len(data)))
	}
	if deps.Search != "" {
		data = append(data, deps.Search)
		whereClause = append(whereClause, fmt.Sprintf("to_tsvector('russian', name) @@ to_tsquery('russian', $%d)", len(data)))
	}

	if len(whereClause) != 0 {
		query = fmt.Sprintf(query, fmt.Sprintf(" WHERE %s ", strings.Join(whereClause, " AND ")))
		queryCnt = fmt.Sprintf(queryCnt, fmt.Sprintf(" WHERE %s ", strings.Join(whereClause, " AND ")))
	} else {
		query = fmt.Sprintf(query, "")
		queryCnt = fmt.Sprintf(queryCnt, "")
	}

	var (
		qerr, cerr error
		count      uint64
		result     []model.Quiz
	)

	data = append(data, deps.Limit, deps.Offset)
	wg := sync.WaitGroup{}
	wg.Add(2)

	go func() {
		defer wg.Done()
		fmt.Println("Q1", query, deps.Limit, deps.Offset)
		rows, err := r.pool.QueryContext(ctx, query, deps.Limit, deps.Offset)
		if err != nil {
			qerr = err
			return
		}

		defer rows.Close()

		var piece model.Quiz
		pIds := pq.Int32Array{}
		for rows.Next() {
			if err := rows.Scan(
				&piece.Id,
				&piece.Qid,
				&piece.AccountId,
				&piece.Deleted,
				&piece.Archived,
				&piece.Fingerprinting,
				&piece.Repeatable,
				&piece.NotePrevented,
				&piece.MailNotifications,
				&piece.UniqueAnswers,
				&piece.Super,
				&piece.GroupId,
				&piece.Name,
				&piece.Description,
				&piece.Config,
				&piece.Status,
				&piece.Limit,
				&piece.DueTo,
				&piece.TimeOfPassing,
				&piece.Pausable,
				&piece.Version,
				&piece.VersionComment,
				&pIds,
				&piece.CreatedAt,
				&piece.UpdatedAt,
				&piece.QuestionsCount,
				&piece.PassedCount,
				&piece.AverageTime,
				&piece.SessionCount,
			); err != nil {
				qerr = err
				return
			}
			piece.ParentIds = pIds
			result = append(result, piece)
		}
	}()

	go func() {
		defer wg.Done()

		fmt.Println("Q2", queryCnt)
		var (
			err  error
			rows *sql.Rows
		)
		if len(data) == 2 {
			rows, err = r.pool.QueryContext(ctx, queryCnt)
		} else {
			rows, err = r.pool.QueryContext(ctx, queryCnt, data[:len(data)-2]...)
		}
		if err != nil {
			cerr = err
			return
		}

		defer rows.Close()

		if !rows.Next() {
			cerr = errors.New("can not next count")
		}

		if err := rows.Scan(&count); err != nil {
			cerr = err
		}
	}()

	wg.Wait()
	fmt.Println("res", result, count, "!", cerr, "?", qerr)
	if cerr != nil {
		return nil, 0, cerr
	}
	if qerr != nil {
		return nil, 0, qerr
	}
	return result, count, nil
}

// test +
// GetQuizByQid method for obtain quiz model by secured id
func (r *QuizRepository) GetQuizByQid(ctx context.Context, qid string) (model.Quiz, error) {
	fmt.Println("QUID", `
SELECT * FROM quiz 
WHERE 
	deleted = false AND 
	archived = false AND
  status = 'start' AND
	qid = $1;
`)
	rows, err := r.pool.QueryContext(ctx, `
SELECT * FROM quiz 
WHERE 
	deleted = false AND 
	archived = false AND
  status = 'start' AND
	qid = $1;
`, qid)
	if err != nil {
		return model.Quiz{}, err
	}
	defer rows.Close()

	if !rows.Next() {
		return model.Quiz{}, rows.Err()
	}

	var piece model.Quiz
	pIds := pq.Int32Array{}
	if err := rows.Scan(
		&piece.Id,
		&piece.Qid,
		&piece.AccountId,
		&piece.Deleted,
		&piece.Archived,
		&piece.Fingerprinting,
		&piece.Repeatable,
		&piece.NotePrevented,
		&piece.MailNotifications,
		&piece.UniqueAnswers,
		&piece.Super,
		&piece.GroupId,
		&piece.Name,
		&piece.Description,
		&piece.Config,
		&piece.Status,
		&piece.Limit,
		&piece.DueTo,
		&piece.TimeOfPassing,
		&piece.Pausable,
		&piece.Version,
		&piece.VersionComment,
		&pIds,
		&piece.CreatedAt,
		&piece.UpdatedAt,
		&piece.QuestionsCount,
		&piece.PassedCount,
		&piece.AverageTime,
		&piece.SessionCount,
	); err != nil {
		return model.Quiz{}, err
	}

	piece.ParentIds = pIds

	return piece, nil
}

// test +
func (r *QuizRepository) DeleteQuiz(ctx context.Context, accountId string, id uint64) (model.Quiz, error) {
	row, err := r.queries.DeleteQuizByID(ctx, sqlcgen.DeleteQuizByIDParams{
		ID:        int64(id),
		Accountid: accountId,
	})

	if err != nil {
		return model.Quiz{}, err
	}

	piece := model.Quiz{
		Id:                uint64(row.ID),
		Qid:               row.Qid.UUID.String(),
		AccountId:         row.Accountid,
		Deleted:           row.Deleted.Bool,
		Archived:          row.Archived.Bool,
		Fingerprinting:    row.Fingerprinting.Bool,
		Repeatable:        row.Repeatable.Bool,
		NotePrevented:     row.NotePrevented.Bool,
		MailNotifications: row.MailNotifications.Bool,
		UniqueAnswers:     row.UniqueAnswers.Bool,
		Super:             row.Super.Bool,
		GroupId:           uint64(row.GroupID.Int64),
		Name:              row.Name.String,
		Description:       row.Description.String,
		Config:            row.Config.String,
		Status:            string(row.Status.([]byte)),
		Limit:             uint64(row.LimitAnswers.Int32),
		DueTo:             uint64(row.DueTo.Int32),
		TimeOfPassing:     uint64(row.TimeOfPassing.Int32),
		Pausable:          row.Pausable.Bool,
		Version:           int(row.Version.Int16),
		VersionComment:    row.VersionComment.String,
		ParentIds:         row.ParentIds,
		CreatedAt:         row.CreatedAt.Time,
		UpdatedAt:         row.UpdatedAt.Time,
		QuestionsCount:    uint64(row.QuestionsCount.Int32),
		PassedCount:       uint64(row.AnswersCount.Int32),
		AverageTime:       uint64(row.AverageTimePassing.Int32),
		SessionCount:      uint64(row.SessionsCount.Int32),
	}

	return piece, nil
}

// test +
// MoveToHistoryQuiz insert deleted duplicate of quiz
func (r *QuizRepository) MoveToHistoryQuiz(ctx context.Context, id uint64, accountId string) (model.Quiz, error) {
	row, err := r.queries.MoveToHistoryQuiz(ctx, sqlcgen.MoveToHistoryQuizParams{
		ID:        int64(id),
		Accountid: accountId,
	})

	if err != nil {
		return model.Quiz{}, err
	}

	result := model.Quiz{
		Id:        uint64(row.ID),
		Qid:       row.Qid.UUID.String(),
		ParentIds: row.ParentIds,
	}

	return result, nil
}

// test +
// UpdateQuiz set new data for quiz
func (r *QuizRepository) UpdateQuiz(ctx context.Context, accountId string, record model.Quiz) error {
	query := `UPDATE quiz SET`
	var params []interface{}

	if record.Name != "" {
		query += ` name = $%d,`
		params = append(params, record.Name)
	}

	if record.Description != "" {
		query += ` description = $%d::text,`
		params = append(params, record.Description)
	}

	if record.Status != "" {
		query += ` status = $%d,`
		params = append(params, record.Status)
	}

	if record.Config != "" {
		query += ` config = $%d::text,`
		params = append(params, record.Config)
	}

	query += ` group_id = $%d, version = $%d WHERE id = $%d AND accountid = $%d`

	params = append(params, record.GroupId, record.Version, record.Id, accountId)
	var placeholders []any
	for i := 1; i <= len(params); i++ {
		placeholders = append(placeholders, i)
	}

	query = fmt.Sprintf(query, placeholders...)

	_, err := r.pool.ExecContext(ctx, query, params...)
	return err
}

// test +
// CopyQuiz method for copy quiz with all of his questions
func (r *QuizRepository) CopyQuiz(ctx context.Context, accountId string, id uint64) (model.Quiz, error) {
	row, err := r.queries.CopyQuiz(ctx, sqlcgen.CopyQuizParams{
		ID:        int64(id),
		Accountid: accountId,
	})

	if err != nil {
		return model.Quiz{}, err
	}

	result := model.Quiz{
		Id:        uint64(row.ID),
		Qid:       row.Qid.UUID.String(),
		CreatedAt: row.CreatedAt.Time,
		UpdatedAt: row.UpdatedAt.Time,
	}

	err = r.queries.CopyQuizQuestions(ctx, sqlcgen.CopyQuizQuestionsParams{
		QuizID:   int64(id),
		QuizID_2: row.ID,
	})
	if err != nil {
		return model.Quiz{}, err
	}

	return result, nil
}

type QuizHistoryDeps struct {
	Id, Limit, Offset uint64
	AccountId         string
}

// test +
// QuizHistory method for obtain quiz history from db
func (r *QuizRepository) QuizHistory(ctx context.Context, deps QuizHistoryDeps) ([]model.Quiz, error) {
	rows, err := r.queries.GetQuizHistory(ctx, sqlcgen.GetQuizHistoryParams{
		ID:        int64(deps.Id),
		Limit:     int32(deps.Limit),
		Offset:    int32(deps.Offset),
		Accountid: deps.AccountId,
	})

	if err != nil {
		return nil, err
	}

	var result []model.Quiz
	for _, row := range rows {
		piece := model.Quiz{
			Id:                uint64(row.ID),
			Qid:               row.Qid.UUID.String(),
			AccountId:         row.Accountid,
			Deleted:           row.Deleted.Bool,
			Archived:          row.Archived.Bool,
			Fingerprinting:    row.Fingerprinting.Bool,
			Repeatable:        row.Repeatable.Bool,
			NotePrevented:     row.NotePrevented.Bool,
			MailNotifications: row.MailNotifications.Bool,
			UniqueAnswers:     row.UniqueAnswers.Bool,
			Super:             row.Super.Bool,
			GroupId:           uint64(row.GroupID.Int64),
			Name:              row.Name.String,
			Description:       row.Description.String,
			Config:            row.Config.String,
			Status:            string(row.Status.([]byte)),
			Limit:             uint64(row.LimitAnswers.Int32),
			DueTo:             uint64(row.DueTo.Int32),
			TimeOfPassing:     uint64(row.TimeOfPassing.Int32),
			Pausable:          row.Pausable.Bool,
			Version:           int(row.Version.Int16),
			VersionComment:    row.VersionComment.String,
			ParentIds:         row.ParentIds,
			CreatedAt:         row.CreatedAt.Time,
			UpdatedAt:         row.UpdatedAt.Time,
			QuestionsCount:    uint64(row.QuestionsCount.Int32),
			PassedCount:       uint64(row.AnswersCount.Int32),
			AverageTime:       uint64(row.AverageTimePassing.Int32),
			SessionCount:      uint64(row.SessionsCount.Int32),
		}

		result = append(result, piece)
	}

	return result, nil
}

func (r *QuizRepository) ArchiveQuiz(ctx context.Context, accountId string, id uint64) error {
	err := r.queries.ArchiveQuiz(ctx, sqlcgen.ArchiveQuizParams{
		ID:        int64(id),
		Accountid: accountId,
	})

	if err != nil {
		return err
	}

	return nil
}

// test +
func (r *QuizRepository) GetQuizById(ctx context.Context, accountId string, id uint64) (*model.Quiz, error) {
	row, err := r.queries.GetQuizById(ctx, sqlcgen.GetQuizByIdParams{
		ID:        int64(id),
		Accountid: accountId,
	})

	if err != nil {
		return nil, err
	}

	piece := model.Quiz{
		Id:                uint64(row.ID),
		Qid:               row.Qid.UUID.String(),
		AccountId:         row.Accountid,
		Deleted:           row.Deleted.Bool,
		Archived:          row.Archived.Bool,
		Fingerprinting:    row.Fingerprinting.Bool,
		Repeatable:        row.Repeatable.Bool,
		NotePrevented:     row.NotePrevented.Bool,
		MailNotifications: row.MailNotifications.Bool,
		UniqueAnswers:     row.UniqueAnswers.Bool,
		Super:             row.Super.Bool,
		GroupId:           uint64(row.GroupID.Int64),
		Name:              row.Name.String,
		Description:       row.Description.String,
		Config:            row.Config.String,
		Status:            string(row.Status.([]byte)),
		Limit:             uint64(row.LimitAnswers.Int32),
		DueTo:             uint64(row.DueTo.Int32),
		TimeOfPassing:     uint64(row.TimeOfPassing.Int32),
		Pausable:          row.Pausable.Bool,
		Version:           int(row.Version.Int16),
		VersionComment:    row.VersionComment.String,
		ParentIds:         row.ParentIds,
		CreatedAt:         row.CreatedAt.Time,
		UpdatedAt:         row.UpdatedAt.Time,
		QuestionsCount:    uint64(row.QuestionsCount.Int32),
		PassedCount:       uint64(row.AnswersCount.Int32),
		AverageTime:       uint64(row.AverageTimePassing.Int32),
		SessionCount:      uint64(row.SessionsCount.Int32),
	}

	return &piece, nil
}

// test +
func (r *QuizRepository) GetQuizConfig(ctx context.Context, quizID uint64) (model.QuizConfig, string, error) {
	row, err := r.queries.GetQuizConfig(ctx, int64(quizID))

	if err != nil {
		return model.QuizConfig{}, "", err
	}

	var config model.QuizConfig
	if err := json.Unmarshal([]byte(row.Config.String), &config); err != nil {
		return model.QuizConfig{}, "", err
	}

	return config, row.Accountid, nil
}

func (r *QuizRepository) QuizMove(ctx context.Context, qID, accountID string) (string, error) {
	qUUID, err := uuid.Parse(qID)
	if err != nil {
		return "", err
	}
	qNullUUID := uuid.NullUUID{UUID: qUUID, Valid: true}

	data, err := r.queries.QuizCopyQid(ctx, sqlcgen.QuizCopyQidParams{
		Qid:       qNullUUID,
		Accountid: accountID,
	})

	if err != nil {
		return "", err
	}

	err = r.queries.CopyQuestionQuizID(ctx, sqlcgen.CopyQuestionQuizIDParams{
		QuizID:   data.ID,
		QuizID_2: data.ID_2,
	})

	if err != nil {
		return "", err
	}

	return data.Qid.UUID.String(), err
}

func (r *QuizRepository) GetAllQuizzesID(ctx context.Context, accountID string) ([]int64, error) {
	ids, err := r.queries.GetListCreatedQuizzes(ctx, accountID)
	if err != nil {
		return []int64{}, err
	}

	return ids, nil
}

func (r *QuizRepository) GetStartedQuizzesID(ctx context.Context, accountID string) ([]int64, error) {
	ids, err := r.queries.GetListStartQuiz(ctx, accountID)
	if err != nil {
		return []int64{}, err
	}

	return ids, nil
}

func (r *QuizRepository) TemplateCopy(ctx context.Context, accountID, qID string) (int64, error) {
	qUUID, err := uuid.Parse(qID)
	if err != nil {
		return 0, err
	}

	qNullUUID := uuid.NullUUID{UUID: qUUID, Valid: true}

	quizID, err := r.queries.TemplateCopy(ctx, sqlcgen.TemplateCopyParams{
		Accountid: accountID,
		Qid:       qNullUUID,
	})

	if err != nil {
		return 0, err
	}

	return quizID, nil
}

func (r *QuizRepository) CheckQuizOwner(ctx context.Context, accountID string, quizID uint64) (bool, error) {
	id, err := r.queries.CheckQuizOwner(ctx, sqlcgen.CheckQuizOwnerParams{
		Accountid: accountID,
		ID:        int64(quizID),
	})
	if err != nil {
		if errors.Is(err, sql.ErrNoRows) {
			return false, nil
		}
		return false, err
	}

	return id == accountID, nil
}