package api

import (
	"context"
	"encoding/json"
	"nyanimedb-server/db"
	"strconv"
	"time"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgtype"
	"golang.org/x/crypto/bcrypt"
)

type Server struct {
	db *db.Queries
}

func NewServer(db *db.Queries) Server {
	return Server{db: db}
}

// —————————————————————————————————————————————
// ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ
// —————————————————————————————————————————————

func parseInt32(s string) (int32, error) {
	i, err := strconv.ParseInt(s, 10, 32)
	return int32(i), err
}

func ptr[T any](v T) *T { return &v }

func pgInt4ToPtr(v pgtype.Int4) *int32 {
	if v.Valid {
		return &v.Int32
	}
	return nil
}

func pgTextToPtr(v pgtype.Text) *string {
	if v.Valid {
		return &v.String
	}
	return nil
}

func pgFloat8ToPtr(v pgtype.Float8) *float64 {
	if v.Valid {
		return &v.Float64
	}
	return nil
}

func jsonbToInterface(data []byte) interface{} {
	if data == nil {
		return nil
	}
	var out interface{}
	if err := json.Unmarshal(data, &out); err != nil {
		return string(data) // fallback
	}
	return out
}

// —————————————————————————————————————————————
// ХЕНДЛЕРЫ
// —————————————————————————————————————————————

func (s Server) GetMedia(ctx context.Context, req GetMediaRequestObject) (GetMediaResponseObject, error) {
	id, err := parseInt32(req.Params.ImageId)
	if err != nil {
		return GetMedia200JSONResponse{Success: ptr(false), Error: ptr("invalid image_id")}, nil
	}
	img, err := s.db.GetImageByID(ctx, id)
	if err != nil {
		if err == pgx.ErrNoRows {
			return GetMedia200JSONResponse{Success: ptr(false), Error: ptr("image not found")}, nil
		}
		return nil, err
	}
	return GetMedia200JSONResponse{
		Success:   ptr(true),
		ImagePath: ptr(img.ImagePath),
	}, nil
}

func (s Server) PostMedia(ctx context.Context, req PostMediaRequestObject) (PostMediaResponseObject, error) {
	// ❗ Не реализовано: OpenAPI не определяет тело запроса для загрузки
	return PostMedia200JSONResponse{
		Success: ptr(false),
		Error:   ptr("upload not implemented: request body not defined in spec"),
	}, nil
}

func (s Server) GetUsers(ctx context.Context, req GetUsersRequestObject) (GetUsersResponseObject, error) {
	users, err := s.db.ListUsers(ctx, db.ListUsersParams{})
	if err != nil {
		return nil, err
	}
	var resp []User
	for _, u := range users {
		resp = append(resp, mapUser(u))
	}
	return GetUsers200JSONResponse(resp), nil
}

func (s Server) PostUsers(ctx context.Context, req PostUsersRequestObject) (PostUsersResponseObject, error) {
	if req.Body == nil {
		return PostUsers200JSONResponse{
			Success: ptr(false),
			Error:   ptr("request body is required"),
		}, nil
	}

	body := *req.Body

	// Обязательные поля
	nickname, ok := body["nickname"].(string)
	if !ok || nickname == "" {
		return PostUsers200JSONResponse{Success: ptr(false), Error: ptr("nickname is required")}, nil
	}

	mail, ok := body["mail"].(string)
	if !ok || mail == "" {
		return PostUsers200JSONResponse{Success: ptr(false), Error: ptr("mail is required")}, nil
	}

	password, ok := body["password"].(string)
	if !ok || password == "" {
		return PostUsers200JSONResponse{Success: ptr(false), Error: ptr("password is required")}, nil
	}

	// Опциональные поля
	var avatarID *int32
	if v, ok := body["avatar_id"].(float64); ok {
		id := int32(v)
		avatarID = &id
	}

	dispName, _ := body["disp_name"].(string)
	userDesc, _ := body["user_desc"].(string)

	// 🔐 Хешируем пароль
	passhashBytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
	if err != nil {
		return PostUsers200JSONResponse{Success: ptr(false), Error: ptr("failed to hash password")}, nil
	}
	passhash := string(passhashBytes)

	// Сохраняем в БД
	_, err = s.db.CreateUser(ctx, db.CreateUserParams{
		AvatarID: pgtype.Int4{
			Int32: 0,
			Valid: avatarID != nil,
		},
		Passhash: passhash,
		Mail: pgtype.Text{
			String: mail,
			Valid:  true,
		},
		Nickname: nickname,
		DispName: pgtype.Text{
			String: dispName,
			Valid:  dispName != "",
		},
		UserDesc: pgtype.Text{
			String: userDesc,
			Valid:  userDesc != "",
		},
		CreationDate: pgtype.Timestamp{
			Time:  time.Now(),
			Valid: true,
		},
	})
	if err != nil {
		// Проверяем нарушение уникальности (например, дубль mail или nickname)
		if err.Error() == "ERROR: duplicate key value violates unique constraint \"users_mail_key\"" ||
			err.Error() == "ERROR: duplicate key value violates unique constraint \"users_nickname_key\"" {
			return PostUsers200JSONResponse{
				Success: ptr(false),
				Error:   ptr("user with this email or nickname already exists"),
			}, nil
		}
		return PostUsers200JSONResponse{Success: ptr(false), Error: ptr("database error")}, nil
	}

	// Получаем созданного пользователя (без passhash и mail!)
	// Предположим, что у вас есть запрос GetUserByNickname или аналогичный
	// Но проще — вернуть только ID и nickname

	// ⚠️ Поскольку мы не знаем user_id, можно:
	//   а) добавить RETURNING в CreateUser (рекомендуется),
	//   б) сделать отдельный SELECT.

	// Пока вернём минимальный ответ
	userResp := User{
		"nickname": nickname,
		// "user_id" можно добавить, если обновите query.sql
	}

	return PostUsers200JSONResponse{
		Success:  ptr(true),
		UserJson: &userResp,
	}, nil
}
func (s Server) DeleteUsersUserId(ctx context.Context, req DeleteUsersUserIdRequestObject) (DeleteUsersUserIdResponseObject, error) {
	userID, err := parseInt32(req.UserId)
	if err != nil {
		return DeleteUsersUserId200JSONResponse{Success: ptr(false), Error: ptr("invalid user_id")}, nil
	}
	err = s.db.DeleteUser(ctx, userID)
	if err != nil {
		if err == pgx.ErrNoRows {
			return DeleteUsersUserId200JSONResponse{Success: ptr(false), Error: ptr("user not found")}, nil
		}
		return nil, err
	}
	return DeleteUsersUserId200JSONResponse{Success: ptr(true)}, nil
}

func (s Server) GetUsersUserId(ctx context.Context, req GetUsersUserIdRequestObject) (GetUsersUserIdResponseObject, error) {
	userID, err := parseInt32(req.UserId)
	if err != nil {
		return GetUsersUserId404Response{}, nil
	}
	user, err := s.db.GetUserByID(ctx, userID)
	if err != nil {
		if err == pgx.ErrNoRows {
			return GetUsersUserId404Response{}, nil
		}
		return nil, err
	}
	return GetUsersUserId200JSONResponse(mapUser(user)), nil
}

func (s Server) PatchUsersUserId(ctx context.Context, req PatchUsersUserIdRequestObject) (PatchUsersUserIdResponseObject, error) {
	userID, err := parseInt32(req.UserId)
	if err != nil {
		return PatchUsersUserId200JSONResponse{Success: ptr(false), Error: ptr("invalid user_id")}, nil
	}
	if req.Body == nil {
		return PatchUsersUserId200JSONResponse{Success: ptr(false), Error: ptr("empty body")}, nil
	}

	body := *req.Body
	args := db.UpdateUserParams{
		UserID: userID,
	}

	if v, ok := body["avatar_id"].(float64); ok {
		args.AvatarID = pgtype.Int4{Int32: int32(v), Valid: true}
		// args.AvatarIDValid = true
	}
	if v, ok := body["disp_name"].(string); ok {
		args.DispName = pgtype.Text{String: v, Valid: true}
		// args.DispNameValid = true
	}
	if v, ok := body["user_desc"].(string); ok {
		args.UserDesc = pgtype.Text{String: v, Valid: true}
		// args.UserDescValid = true
	}

	_, err = s.db.UpdateUser(ctx, args)
	if err != nil {
		return PatchUsersUserId200JSONResponse{Success: ptr(false), Error: ptr(err.Error())}, nil
	}
	return PatchUsersUserId200JSONResponse{Success: ptr(true)}, nil
}

func (s Server) GetUsersUserIdReviews(ctx context.Context, req GetUsersUserIdReviewsRequestObject) (GetUsersUserIdReviewsResponseObject, error) {
	userID, err := parseInt32(req.UserId)
	if err != nil {
		return GetUsersUserIdReviews200JSONResponse{}, nil
	}
	limit := int32(20)
	offset := int32(0)
	// if req.Params.Limit != nil {
	// 	limit = int32(*req.Params.Limit)
	// }
	// if req.Params.Offset != nil {
	// 	offset = int32(*req.Params.Offset)
	// }

	reviews, err := s.db.ListReviewsByUser(ctx, db.ListReviewsByUserParams{
		UserID: userID,
		Limit:  limit,
		Offset: offset,
	})
	if err != nil {
		return nil, err
	}

	var resp []Review
	for _, r := range reviews {
		resp = append(resp, mapReview(r))
	}
	return GetUsersUserIdReviews200JSONResponse(resp), nil
}

func (s Server) DeleteUsersUserIdTitles(ctx context.Context, req DeleteUsersUserIdTitlesRequestObject) (DeleteUsersUserIdTitlesResponseObject, error) {
	userID, err := parseInt32(req.UserId)
	if err != nil {
		return DeleteUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr("invalid user_id")}, nil
	}

	if req.Params.TitleId != nil {
		titleID, err := parseInt32(*req.Params.TitleId)
		if err != nil {
			return DeleteUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr("invalid title_id")}, nil
		}
		err = s.db.DeleteUserTitle(ctx, db.DeleteUserTitleParams{
			UserID:  userID,
			Column2: titleID,
		})
		if err != nil && err != pgx.ErrNoRows {
			return nil, err
		}
	}
	// else {
	// 	err = s.db.DeleteAllUserTitles(ctx, userID)
	// 	if err != nil {
	// 		return nil, err
	// 	}
	// }
	return DeleteUsersUserIdTitles200JSONResponse{Success: ptr(true)}, nil
}

func (s Server) GetUsersUserIdTitles(ctx context.Context, req GetUsersUserIdTitlesRequestObject) (GetUsersUserIdTitlesResponseObject, error) {
	userID, err := parseInt32(req.UserId)
	if err != nil {
		return GetUsersUserIdTitles200JSONResponse{}, nil
	}
	limit := int32(100)
	offset := int32(0)
	if req.Params.Limit != nil {
		limit = int32(*req.Params.Limit)
	}
	if req.Params.Offset != nil {
		offset = int32(*req.Params.Offset)
	}

	titles, err := s.db.ListUserTitles(ctx, db.ListUserTitlesParams{
		UserID: userID,
		Limit:  limit,
		Offset: offset,
	})
	if err != nil {
		return nil, err
	}

	var resp []UserTitle
	for _, t := range titles {
		resp = append(resp, mapUserTitle(t))
	}
	return GetUsersUserIdTitles200JSONResponse(resp), nil
}

func (s Server) PatchUsersUserIdTitles(ctx context.Context, req PatchUsersUserIdTitlesRequestObject) (PatchUsersUserIdTitlesResponseObject, error) {
	// 	userID, err := parseInt32(req.UserId)
	// 	if err != nil {
	// 		return PatchUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr("invalid user_id")}, nil
	// 	}
	// 	if req.Body == nil {
	// 		return PatchUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr("empty body")}, nil
	// 	}

	// 	body := *req.Body
	// 	titleID, ok := body["title_id"].(float64)
	// 	if !ok {
	// 		return PatchUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr("title_id required")}, nil
	// 	}

	// 	args := db.UpdateUserTitleParams{
	// 		UserID:  userID,
	// 		TitleID: int32(titleID),
	// 	}

	// 	if v, ok := body["status"].(string); ok {
	// 		args.Status = db.UsertitleStatusT(v)
	// 		// args.StatusValid = true
	// 	}
	// 	if v, ok := body["rate"].(float64); ok {
	// 		args.Rate = pgtype.Int4{Int32: int32(v), Valid: true}
	// 		// args.RateValid = true
	// 	}
	// 	if v, ok := body["review_id"].(float64); ok {
	// 		args.ReviewID = pgtype.Int4{Int32: int32(v), Valid: true}
	// 		// args.ReviewIDValid = true
	// 	}

	// 	_, err = s.db.UpdateUserTitle(ctx, args)
	// 	if err != nil {
	// 		return PatchUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr(err.Error())}, nil
	// 	}
	return PatchUsersUserIdTitles200JSONResponse{Success: ptr(true)}, nil
}

func (s Server) PostUsersUserIdTitles(ctx context.Context, req PostUsersUserIdTitlesRequestObject) (PostUsersUserIdTitlesResponseObject, error) {
	userID, err := parseInt32(req.UserId)
	if err != nil {
		return PostUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr("invalid user_id")}, nil
	}
	if req.Body == nil {
		return PostUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr("empty body")}, nil
	}

	body := req.Body
	titleID, err := parseInt32(*body.TitleId)
	if err != nil {
		return PostUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr("invalid title_id")}, nil
	}

	status := db.UsertitleStatusT("planned")
	if body.Status != nil {
		status = db.UsertitleStatusT(*body.Status)
	}

	_, err = s.db.CreateUserTitle(ctx, db.CreateUserTitleParams{
		UserID:   userID,
		TitleID:  titleID,
		Status:   status,
		Rate:     pgtype.Int4{Valid: false},
		ReviewID: pgtype.Int4{Valid: false},
	})
	if err != nil {
		return PostUsersUserIdTitles200JSONResponse{Success: ptr(false), Error: ptr(err.Error())}, nil
	}
	return PostUsersUserIdTitles200JSONResponse{Success: ptr(true)}, nil
}

func (s Server) GetTags(ctx context.Context, req GetTagsRequestObject) (GetTagsResponseObject, error) {
	limit := int32(100)
	offset := int32(0)
	if req.Params.Limit != nil {
		limit = int32(*req.Params.Limit)
	}
	if req.Params.Offset != nil {
		offset = int32(*req.Params.Offset)
	}
	tags, err := s.db.ListTags(ctx, db.ListTagsParams{Limit: limit, Offset: offset})
	if err != nil {
		return nil, err
	}
	var resp []Tag
	for _, t := range tags {
		resp = append(resp, Tag{
			"tag_id":    t.TagID,
			"tag_names": jsonbToInterface(t.TagNames),
		})
	}
	return GetTags200JSONResponse(resp), nil
}

func (s Server) GetTitle(ctx context.Context, req GetTitleRequestObject) (GetTitleResponseObject, error) {
	limit := int32(50)
	offset := int32(0)
	if req.Params.Limit != nil {
		limit = int32(*req.Params.Limit)
	}
	if req.Params.Offset != nil {
		offset = int32(*req.Params.Offset)
	}
	titles, err := s.db.ListTitles(ctx, db.ListTitlesParams{Limit: limit, Offset: offset})
	if err != nil {
		return nil, err
	}
	var resp []Title
	for _, t := range titles {
		resp = append(resp, mapTitle(t))
	}
	return GetTitle200JSONResponse(resp), nil
}

func (s Server) GetTitleTitleId(ctx context.Context, req GetTitleTitleIdRequestObject) (GetTitleTitleIdResponseObject, error) {
	titleID, err := parseInt32(req.TitleId)
	if err != nil {
		return GetTitleTitleId404Response{}, nil
	}
	title, err := s.db.GetTitleByID(ctx, titleID)
	if err != nil {
		if err == pgx.ErrNoRows {
			return GetTitleTitleId404Response{}, nil
		}
		return nil, err
	}
	return GetTitleTitleId200JSONResponse(mapTitle(title)), nil
}

func (s Server) PatchTitleTitleId(ctx context.Context, req PatchTitleTitleIdRequestObject) (PatchTitleTitleIdResponseObject, error) {
	titleID, err := parseInt32(req.TitleId)
	if err != nil {
		return PatchTitleTitleId200JSONResponse{Success: ptr(false), Error: ptr("invalid title_id")}, nil
	}
	if req.Body == nil {
		return PatchTitleTitleId200JSONResponse{Success: ptr(false), Error: ptr("empty body")}, nil
	}

	body := *req.Body
	args := db.UpdateTitleParams{
		TitleID: titleID,
	}

	if v, ok := body["title_names"].(map[string]interface{}); ok {
		data, _ := json.Marshal(v)
		args.TitleNames = data
		// args.TitleNamesValid = true
	}
	if v, ok := body["studio_id"].(float64); ok {
		args.StudioID = pgtype.Int4{Int32: int32(v), Valid: true}
		// args.StudioIDValid = true
	}
	if v, ok := body["poster_id"].(float64); ok {
		args.PosterID = pgtype.Int4{Int32: int32(v), Valid: true}
		// args.PosterIDValid = true
	}
	// if v, ok := body["title_status"].(string); ok {
	// 	args.TitleStatus = db.NullTitleStatusT(v)
	// 	// args.TitleStatusValid = true
	// }
	if v, ok := body["release_year"].(float64); ok {
		args.ReleaseYear = pgtype.Int4{Int32: int32(v), Valid: true}
		// args.ReleaseYearValid = true
	}
	if v, ok := body["episodes_aired"].(float64); ok {
		args.EpisodesAired = pgtype.Int4{Int32: int32(v), Valid: true}
		// args.EpisodesAiredValid = true
	}
	if v, ok := body["episodes_all"].(float64); ok {
		args.EpisodesAll = pgtype.Int4{Int32: int32(v), Valid: true}
		// args.EpisodesAllValid = true
	}

	_, err = s.db.UpdateTitle(ctx, args)
	if err != nil {
		return PatchTitleTitleId200JSONResponse{Success: ptr(false), Error: ptr(err.Error())}, nil
	}
	return PatchTitleTitleId200JSONResponse{Success: ptr(true)}, nil
}

func (s Server) GetTitleTitleIdReviews(ctx context.Context, req GetTitleTitleIdReviewsRequestObject) (GetTitleTitleIdReviewsResponseObject, error) {
	titleID, err := parseInt32(req.TitleId)
	if err != nil {
		return GetTitleTitleIdReviews200JSONResponse{}, nil
	}
	limit := int32(20)
	offset := int32(0)
	if req.Params.Limit != nil {
		limit = int32(*req.Params.Limit)
	}
	if req.Params.Offset != nil {
		offset = int32(*req.Params.Offset)
	}

	reviews, err := s.db.ListReviewsByTitle(ctx, db.ListReviewsByTitleParams{
		TitleID: titleID,
		Limit:   limit,
		Offset:  offset,
	})
	if err != nil {
		return nil, err
	}

	var resp []Review
	for _, r := range reviews {
		resp = append(resp, mapReview(r))
	}
	return GetTitleTitleIdReviews200JSONResponse(resp), nil
}

func (s Server) PostReviews(ctx context.Context, req PostReviewsRequestObject) (PostReviewsResponseObject, error) {
	if req.Body == nil {
		return PostReviews200JSONResponse{Success: ptr(false), Error: ptr("empty body")}, nil
	}

	body := *req.Body
	userID, ok1 := body["user_id"].(float64)
	titleID, ok2 := body["title_id"].(float64)
	reviewText, ok3 := body["review_text"].(string)
	if !ok1 || !ok2 || !ok3 {
		return PostReviews200JSONResponse{Success: ptr(false), Error: ptr("user_id, title_id, review_text required")}, nil
	}

	var imageIDs []int32
	if ids, ok := body["image_ids"].([]interface{}); ok {
		for _, id := range ids {
			if f, ok := id.(float64); ok {
				imageIDs = append(imageIDs, int32(f))
			}
		}
	}

	_, err := s.db.CreateReview(ctx, db.CreateReviewParams{
		UserID:       int32(userID),
		TitleID:      int32(titleID),
		ImageIds:     imageIDs,
		ReviewText:   reviewText,
		CreationDate: pgtype.Timestamp{Time: time.Now(), Valid: true},
	})
	if err != nil {
		return PostReviews200JSONResponse{Success: ptr(false), Error: ptr(err.Error())}, nil
	}

	return PostReviews200JSONResponse{Success: ptr(true)}, nil
}

func (s Server) DeleteReviewsReviewId(ctx context.Context, req DeleteReviewsReviewIdRequestObject) (DeleteReviewsReviewIdResponseObject, error) {
	reviewID, err := parseInt32(req.ReviewId)
	if err != nil {
		return DeleteReviewsReviewId200JSONResponse{Success: ptr(false), Error: ptr("invalid review_id")}, nil
	}
	err = s.db.DeleteReview(ctx, reviewID)
	if err != nil {
		if err == pgx.ErrNoRows {
			return DeleteReviewsReviewId200JSONResponse{Success: ptr(false), Error: ptr("review not found")}, nil
		}
		return nil, err
	}
	return DeleteReviewsReviewId200JSONResponse{Success: ptr(true)}, nil
}

func (s Server) PatchReviewsReviewId(ctx context.Context, req PatchReviewsReviewIdRequestObject) (PatchReviewsReviewIdResponseObject, error) {
	reviewID, err := parseInt32(req.ReviewId)
	if err != nil {
		return PatchReviewsReviewId200JSONResponse{Success: ptr(false), Error: ptr("invalid review_id")}, nil
	}
	if req.Body == nil {
		return PatchReviewsReviewId200JSONResponse{Success: ptr(false), Error: ptr("empty body")}, nil
	}

	body := *req.Body
	args := db.UpdateReviewParams{
		ReviewID: reviewID,
	}

	if v, ok := body["review_text"].(string); ok {
		args.ReviewText = pgtype.Text{String: v, Valid: true}
		// args.ReviewTextValid = true
	}
	if ids, ok := body["image_ids"].([]interface{}); ok {
		var imageIDs []int32
		for _, id := range ids {
			if f, ok := id.(float64); ok {
				imageIDs = append(imageIDs, int32(f))
			}
		}
		args.ImageIds = imageIDs
		// args.ImageIdsValid = true
	}

	_, err = s.db.UpdateReview(ctx, args)
	if err != nil {
		return PatchReviewsReviewId200JSONResponse{Success: ptr(false), Error: ptr(err.Error())}, nil
	}
	return PatchReviewsReviewId200JSONResponse{Success: ptr(true)}, nil
}

// —————————————————————————————————————————————
// МАППИНГИ
// —————————————————————————————————————————————

func mapUser(u db.Users) User {
	return User{
		"user_id":       u.UserID,
		"avatar_id":     pgInt4ToPtr(u.AvatarID),
		"nickname":      u.Nickname,
		"disp_name":     pgTextToPtr(u.DispName),
		"user_desc":     pgTextToPtr(u.UserDesc),
		"creation_date": u.CreationDate.Time,
		// mail и passhash НЕ возвращаем!
	}
}

func mapTitle(t db.Titles) Title {
	var releaseSeason interface{}
	if t.ReleaseSeason.Valid {
		releaseSeason = string(t.ReleaseSeason.ReleaseSeasonT)
	}

	return Title{
		"title_id":       t.TitleID,
		"title_names":    jsonbToInterface(t.TitleNames),
		"studio_id":      t.StudioID,
		"poster_id":      pgInt4ToPtr(t.PosterID),
		"signal_ids":     t.SignalIds,
		"title_status":   string(t.TitleStatus),
		"rating":         pgFloat8ToPtr(t.Rating),
		"rating_count":   pgInt4ToPtr(t.RatingCount),
		"release_year":   pgInt4ToPtr(t.ReleaseYear),
		"release_season": releaseSeason,
		"season":         pgInt4ToPtr(t.Season),
		"episodes_aired": pgInt4ToPtr(t.EpisodesAired),
		"episodes_all":   pgInt4ToPtr(t.EpisodesAll),
		"episodes_len":   jsonbToInterface(t.EpisodesLen),
	}
}

func mapReview(r db.Reviews) Review {
	return Review{
		"review_id":     r.ReviewID,
		"user_id":       r.UserID,
		"title_id":      r.TitleID,
		"image_ids":     r.ImageIds,
		"review_text":   r.ReviewText,
		"creation_date": r.CreationDate.Time,
	}
}

func mapUserTitle(ut db.Usertitles) UserTitle {
	return UserTitle{
		"usertitle_id": ut.UsertitleID,
		"user_id":      ut.UserID,
		"title_id":     ut.TitleID,
		"status":       string(ut.Status),
		"rate":         pgInt4ToPtr(ut.Rate),
		"review_id":    pgInt4ToPtr(ut.ReviewID),
	}
}