Goondex/internal/scraper/tpdb/mapper.go

package tpdb

import (
	"fmt"
	"strconv"
	"strings"

	"git.leaktechnologies.dev/stu/Goondex/internal/model"
)

// mapPerformer converts a TPDB performer to our internal model
func mapPerformer(p PerformerResponse) model.Performer {
	performer := model.Performer{
		Name:     p.Name,
		Source:   "tpdb",
		SourceID: p.ID,
	}

	// Map optional fields
	if len(p.Aliases) > 0 {
		performer.Aliases = strings.Join(p.Aliases, ", ")
	}

	if p.Gender != "" {
		performer.Gender = p.Gender
	}

	if p.Nationality != nil {
		performer.Country = *p.Nationality
		performer.Nationality = *p.Nationality
	}

	if p.Image != nil {
		performer.ImageURL = *p.Image
	}

	// Build bio from available information
	bio := ""
	if p.Bio != nil {
		bio = *p.Bio
	}
	performer.Bio = bio

	return performer
}

// mapStudio converts a TPDB studio to our internal model
func mapStudio(s StudioResponse) model.Studio {
	studio := model.Studio{
		Name:     s.Name,
		Source:   "tpdb",
		SourceID: strconv.Itoa(s.ID),
	}

	if s.Description != nil {
		studio.Description = *s.Description
	}

	if s.Logo != nil {
		studio.ImageURL = *s.Logo
	}

	// Handle parent studio
	if s.Parent != nil {
		// We'll need to look up or create the parent studio separately
		// For now, we'll store the parent ID as a string that needs to be resolved
		// This is a limitation that should be handled by the import logic
	}

	return studio
}

// mapScene converts a TPDB scene to our internal model
func mapScene(s SceneResponse) model.Scene {
	scene := model.Scene{
		Title:    s.Title,
		Source:   "tpdb",
		SourceID: s.ID,
	}

	if s.Description != nil {
		scene.Description = *s.Description
	}

	if s.URL != nil {
		scene.URL = *s.URL
	}

	if s.Date != nil {
		scene.Date = *s.Date
	}

	if s.Image != nil {
		scene.ImageURL = *s.Image
	}

	if s.Director != nil {
		scene.Director = *s.Director
	}

	if s.Code != nil {
		scene.Code = *s.Code
	}

	// Map performers
	if len(s.Performers) > 0 {
		performers := make([]model.Performer, 0, len(s.Performers))
		for _, p := range s.Performers {
			performer := model.Performer{
				Name:     p.Name,
				Source:   "tpdb",
				SourceID: p.ID,
			}
			if p.Gender != nil {
				performer.Gender = *p.Gender
			}
			performers = append(performers, performer)
		}
		scene.Performers = performers
	}

	// Map tags
	if len(s.Tags) > 0 {
		tags := make([]model.Tag, 0, len(s.Tags))
		for _, t := range s.Tags {
			tag := model.Tag{
				Name:     t.Name,
				Source:   "tpdb",
				SourceID: t.ID,
			}
			tags = append(tags, tag)
		}
		scene.Tags = tags
	}

	// Map studio
	if s.Site != nil {
		studio := model.Studio{
			Name:     s.Site.Name,
			Source:   "tpdb",
			SourceID: strconv.Itoa(s.Site.ID),
		}
		if s.Site.URL != nil {
			studio.Description = fmt.Sprintf("URL: %s", *s.Site.URL)
		}
		scene.Studio = &studio
	}

	return scene
}

// stringToInt64 safely converts a string to int64
func stringToInt64(s string) (int64, error) {
	return strconv.ParseInt(s, 10, 64)
}