package store

import (
	"encoding/json"
	"fmt"
	"time"

	"github.com/google/uuid"

	"git.warky.dev/wdevs/amcs/internal/generatedmodels"
	ext "git.warky.dev/wdevs/amcs/internal/types"
)

func projectFromModel(m generatedmodels.ModelPublicProjects) ext.Project {
	return ext.Project{
		ID:           m.GUID.UUID(),
		Name:         m.Name.String(),
		Description:  m.Description.String(),
		CreatedAt:    m.CreatedAt.Time(),
		LastActiveAt: m.LastActiveAt.Time(),
	}
}

func thoughtFromModel(m generatedmodels.ModelPublicThoughts) (ext.Thought, error) {
	var metadata ext.ThoughtMetadata
	if len(m.Metadata) > 0 {
		if err := json.Unmarshal(m.Metadata, &metadata); err != nil {
			return ext.Thought{}, fmt.Errorf("decode thought metadata: %w", err)
		}
	}

	var projectID *uuid.UUID
	if m.ProjectID.Valid {
		id := m.ProjectID.UUID()
		projectID = &id
	}

	var archivedAt *time.Time
	if m.ArchivedAt.Valid {
		t := m.ArchivedAt.Time()
		archivedAt = &t
	}

	return ext.Thought{
		ID:         m.GUID.UUID(),
		Content:    m.Content.String(),
		Metadata:   metadata,
		ProjectID:  projectID,
		ArchivedAt: archivedAt,
		CreatedAt:  m.CreatedAt.Time(),
		UpdatedAt:  m.UpdatedAt.Time(),
	}, nil
}

func storedFileFromModel(m generatedmodels.ModelPublicStoredFiles) ext.StoredFile {
	var thoughtID *uuid.UUID
	if m.ThoughtID.Valid {
		id := m.ThoughtID.UUID()
		thoughtID = &id
	}

	var projectID *uuid.UUID
	if m.ProjectID.Valid {
		id := m.ProjectID.UUID()
		projectID = &id
	}

	return ext.StoredFile{
		ID:        m.GUID.UUID(),
		ThoughtID: thoughtID,
		ProjectID: projectID,
		Name:      m.Name.String(),
		MediaType: m.MediaType.String(),
		Kind:      m.Kind.String(),
		Encoding:  m.Encoding.String(),
		SizeBytes: m.SizeBytes,
		SHA256:    m.Sha256.String(),
		Content:   m.Content,
		CreatedAt: m.CreatedAt.Time(),
		UpdatedAt: m.UpdatedAt.Time(),
	}
}

func maintenanceTaskFromModel(m generatedmodels.ModelPublicMaintenanceTasks) ext.MaintenanceTask {
	var frequencyDays *int
	if m.FrequencyDays.Valid {
		n := int(m.FrequencyDays.Int64())
		frequencyDays = &n
	}

	var lastCompleted *time.Time
	if m.LastCompleted.Valid {
		t := m.LastCompleted.Time()
		lastCompleted = &t
	}

	var nextDue *time.Time
	if m.NextDue.Valid {
		t := m.NextDue.Time()
		nextDue = &t
	}

	return ext.MaintenanceTask{
		ID:            m.ID.UUID(),
		Name:          m.Name.String(),
		Category:      m.Category.String(),
		FrequencyDays: frequencyDays,
		LastCompleted: lastCompleted,
		NextDue:       nextDue,
		Priority:      m.Priority.String(),
		Notes:         m.Notes.String(),
		CreatedAt:     m.CreatedAt.Time(),
		UpdatedAt:     m.UpdatedAt.Time(),
	}
}

func maintenanceLogFromModel(m generatedmodels.ModelPublicMaintenanceLogs) ext.MaintenanceLog {
	var cost *float64
	if m.Cost.Valid {
		v := m.Cost.Float64()
		cost = &v
	}

	return ext.MaintenanceLog{
		ID:          m.ID.UUID(),
		TaskID:      m.TaskID.UUID(),
		CompletedAt: m.CompletedAt.Time(),
		PerformedBy: m.PerformedBy.String(),
		Cost:        cost,
		Notes:       m.Notes.String(),
		NextAction:  m.NextAction.String(),
	}
}

func householdItemFromModel(m generatedmodels.ModelPublicHouseholdItems) ext.HouseholdItem {
	details := map[string]any{}
	if len(m.Details) > 0 {
		if err := json.Unmarshal(m.Details, &details); err != nil {
			details = map[string]any{}
		}
	}

	return ext.HouseholdItem{
		ID:        m.ID.UUID(),
		Name:      m.Name.String(),
		Category:  m.Category.String(),
		Location:  m.Location.String(),
		Details:   details,
		Notes:     m.Notes.String(),
		CreatedAt: m.CreatedAt.Time(),
		UpdatedAt: m.UpdatedAt.Time(),
	}
}

func householdVendorFromModel(m generatedmodels.ModelPublicHouseholdVendors) ext.HouseholdVendor {
	var rating *int
	if m.Rating.Valid {
		v := int(m.Rating.Int64())
		rating = &v
	}

	var lastUsed *time.Time
	if m.LastUsed.Valid {
		t := m.LastUsed.Time()
		lastUsed = &t
	}

	return ext.HouseholdVendor{
		ID:          m.ID.UUID(),
		Name:        m.Name.String(),
		ServiceType: m.ServiceType.String(),
		Phone:       m.Phone.String(),
		Email:       m.Email.String(),
		Website:     m.Website.String(),
		Notes:       m.Notes.String(),
		Rating:      rating,
		LastUsed:    lastUsed,
		CreatedAt:   m.CreatedAt.Time(),
	}
}

func familyMemberFromModel(m generatedmodels.ModelPublicFamilyMembers) ext.FamilyMember {
	var birthDate *time.Time
	if m.BirthDate.Valid {
		t := m.BirthDate.Time()
		birthDate = &t
	}

	return ext.FamilyMember{
		ID:           m.ID.UUID(),
		Name:         m.Name.String(),
		Relationship: m.Relationship.String(),
		BirthDate:    birthDate,
		Notes:        m.Notes.String(),
		CreatedAt:    m.CreatedAt.Time(),
	}
}

func activityFromModel(m generatedmodels.ModelPublicActivities, memberName string) ext.Activity {
	var familyMemberID *uuid.UUID
	if m.FamilyMemberID.Valid {
		id := m.FamilyMemberID.UUID()
		familyMemberID = &id
	}

	var startDate *time.Time
	if m.StartDate.Valid {
		t := m.StartDate.Time()
		startDate = &t
	}

	var endDate *time.Time
	if m.EndDate.Valid {
		t := m.EndDate.Time()
		endDate = &t
	}

	return ext.Activity{
		ID:             m.ID.UUID(),
		FamilyMemberID: familyMemberID,
		MemberName:     memberName,
		Title:          m.Title.String(),
		ActivityType:   m.ActivityType.String(),
		DayOfWeek:      m.DayOfWeek.String(),
		StartTime:      m.StartTime.String(),
		EndTime:        m.EndTime.String(),
		StartDate:      startDate,
		EndDate:        endDate,
		Location:       m.Location.String(),
		Notes:          m.Notes.String(),
		CreatedAt:      m.CreatedAt.Time(),
	}
}

func importantDateFromModel(m generatedmodels.ModelPublicImportantDates, memberName string) ext.ImportantDate {
	var familyMemberID *uuid.UUID
	if m.FamilyMemberID.Valid {
		id := m.FamilyMemberID.UUID()
		familyMemberID = &id
	}

	return ext.ImportantDate{
		ID:                 m.ID.UUID(),
		FamilyMemberID:     familyMemberID,
		MemberName:         memberName,
		Title:              m.Title.String(),
		DateValue:          m.DateValue.Time(),
		RecurringYearly:    m.RecurringYearly,
		ReminderDaysBefore: int(m.ReminderDaysBefore),
		Notes:              m.Notes.String(),
		CreatedAt:          m.CreatedAt.Time(),
	}
}

func professionalContactFromModel(m generatedmodels.ModelPublicProfessionalContacts, tags []string) ext.ProfessionalContact {
	var lastContacted *time.Time
	if m.LastContacted.Valid {
		t := m.LastContacted.Time()
		lastContacted = &t
	}

	var followUpDate *time.Time
	if m.FollowUpDate.Valid {
		t := m.FollowUpDate.Time()
		followUpDate = &t
	}

	return ext.ProfessionalContact{
		ID:            m.ID.UUID(),
		Name:          m.Name.String(),
		Company:       m.Company.String(),
		Title:         m.Title.String(),
		Email:         m.Email.String(),
		Phone:         m.Phone.String(),
		LinkedInURL:   m.LinkedinURL.String(),
		HowWeMet:      m.HowWeMet.String(),
		Tags:          tags,
		Notes:         m.Notes.String(),
		LastContacted: lastContacted,
		FollowUpDate:  followUpDate,
		CreatedAt:     m.CreatedAt.Time(),
		UpdatedAt:     m.UpdatedAt.Time(),
	}
}

func contactInteractionFromModel(m generatedmodels.ModelPublicContactInteractions) ext.ContactInteraction {
	return ext.ContactInteraction{
		ID:              m.ID.UUID(),
		ContactID:       m.ContactID.UUID(),
		InteractionType: m.InteractionType.String(),
		OccurredAt:      m.OccurredAt.Time(),
		Summary:         m.Summary.String(),
		FollowUpNeeded:  m.FollowUpNeeded,
		FollowUpNotes:   m.FollowUpNotes.String(),
		CreatedAt:       m.CreatedAt.Time(),
	}
}

func opportunityFromModel(m generatedmodels.ModelPublicOpportunities) ext.Opportunity {
	var contactID *uuid.UUID
	if m.ContactID.Valid {
		id := m.ContactID.UUID()
		contactID = &id
	}

	var value *float64
	if m.Value.Valid {
		v := m.Value.Float64()
		value = &v
	}

	var expectedCloseDate *time.Time
	if m.ExpectedCloseDate.Valid {
		t := m.ExpectedCloseDate.Time()
		expectedCloseDate = &t
	}

	return ext.Opportunity{
		ID:                m.ID.UUID(),
		ContactID:         contactID,
		Title:             m.Title.String(),
		Description:       m.Description.String(),
		Stage:             m.Stage.String(),
		Value:             value,
		ExpectedCloseDate: expectedCloseDate,
		Notes:             m.Notes.String(),
		CreatedAt:         m.CreatedAt.Time(),
		UpdatedAt:         m.UpdatedAt.Time(),
	}
}

func recipeFromModel(m generatedmodels.ModelPublicRecipes, tags []string) ext.Recipe {
	var prepTimeMinutes *int
	if m.PrepTimeMinutes.Valid {
		v := int(m.PrepTimeMinutes.Int64())
		prepTimeMinutes = &v
	}

	var cookTimeMinutes *int
	if m.CookTimeMinutes.Valid {
		v := int(m.CookTimeMinutes.Int64())
		cookTimeMinutes = &v
	}

	var servings *int
	if m.Servings.Valid {
		v := int(m.Servings.Int64())
		servings = &v
	}

	var rating *int
	if m.Rating.Valid {
		v := int(m.Rating.Int64())
		rating = &v
	}

	recipe := ext.Recipe{
		ID:              m.ID.UUID(),
		Name:            m.Name.String(),
		Cuisine:         m.Cuisine.String(),
		PrepTimeMinutes: prepTimeMinutes,
		CookTimeMinutes: cookTimeMinutes,
		Servings:        servings,
		Tags:            tags,
		Rating:          rating,
		Notes:           m.Notes.String(),
		CreatedAt:       m.CreatedAt.Time(),
		UpdatedAt:       m.UpdatedAt.Time(),
	}

	if err := json.Unmarshal(m.Ingredients, &recipe.Ingredients); err != nil {
		recipe.Ingredients = []ext.Ingredient{}
	}
	if err := json.Unmarshal(m.Instructions, &recipe.Instructions); err != nil {
		recipe.Instructions = []string{}
	}
	return recipe
}

func mealPlanEntryFromModel(m generatedmodels.ModelPublicMealPlans, recipeName string) ext.MealPlanEntry {
	var recipeID *uuid.UUID
	if m.RecipeID.Valid {
		id := m.RecipeID.UUID()
		recipeID = &id
	}

	var servings *int
	if m.Servings.Valid {
		v := int(m.Servings.Int64())
		servings = &v
	}

	return ext.MealPlanEntry{
		ID:         m.ID.UUID(),
		WeekStart:  m.WeekStart.Time(),
		DayOfWeek:  m.DayOfWeek.String(),
		MealType:   m.MealType.String(),
		RecipeID:   recipeID,
		RecipeName: recipeName,
		CustomMeal: m.CustomMeal.String(),
		Servings:   servings,
		Notes:      m.Notes.String(),
		CreatedAt:  m.CreatedAt.Time(),
	}
}

func shoppingListFromModel(m generatedmodels.ModelPublicShoppingLists) ext.ShoppingList {
	list := ext.ShoppingList{
		ID:        m.ID.UUID(),
		WeekStart: m.WeekStart.Time(),
		Notes:     m.Notes.String(),
		CreatedAt: m.CreatedAt.Time(),
		UpdatedAt: m.UpdatedAt.Time(),
	}
	if err := json.Unmarshal(m.Items, &list.Items); err != nil {
		list.Items = []ext.ShoppingItem{}
	}
	return list
}

func planFromModel(m generatedmodels.ModelPublicPlans, tags []string) ext.Plan {
	var projectID *uuid.UUID
	if m.ProjectID.Valid {
		id := m.ProjectID.UUID()
		projectID = &id
	}

	var dueDate *time.Time
	if m.DueDate.Valid {
		t := m.DueDate.Time()
		dueDate = &t
	}

	var completedAt *time.Time
	if m.CompletedAt.Valid {
		t := m.CompletedAt.Time()
		completedAt = &t
	}

	var lastReviewedAt *time.Time
	if m.LastReviewedAt.Valid {
		t := m.LastReviewedAt.Time()
		lastReviewedAt = &t
	}

	var supersedesPlanID *uuid.UUID
	if m.SupersedesPlanID.Valid {
		id := m.SupersedesPlanID.UUID()
		supersedesPlanID = &id
	}

	return ext.Plan{
		ID:               m.ID.UUID(),
		Title:            m.Title.String(),
		Description:      m.Description.String(),
		Status:           ext.PlanStatus(m.Status.String()),
		Priority:         ext.PlanPriority(m.Priority.String()),
		ProjectID:        projectID,
		Owner:            m.Owner.String(),
		DueDate:          dueDate,
		CompletedAt:      completedAt,
		ReviewedBy:       m.ReviewedBy.String(),
		LastReviewedAt:   lastReviewedAt,
		SupersedesPlanID: supersedesPlanID,
		Tags:             tags,
		CreatedAt:        m.CreatedAt.Time(),
		UpdatedAt:        m.UpdatedAt.Time(),
	}
}

func learningFromModel(m generatedmodels.ModelPublicLearnings, tags []string) ext.Learning {
	var projectID *uuid.UUID
	if m.ProjectID.Valid {
		id := m.ProjectID.UUID()
		projectID = &id
	}

	var relatedThoughtID *uuid.UUID
	if m.RelatedThoughtID.Valid {
		id := m.RelatedThoughtID.UUID()
		relatedThoughtID = &id
	}

	var relatedSkillID *uuid.UUID
	if m.RelatedSkillID.Valid {
		id := m.RelatedSkillID.UUID()
		relatedSkillID = &id
	}

	var duplicateOfLearningID *uuid.UUID
	if m.DuplicateOfLearningID.Valid {
		id := m.DuplicateOfLearningID.UUID()
		duplicateOfLearningID = &id
	}

	var supersedesLearningID *uuid.UUID
	if m.SupersedesLearningID.Valid {
		id := m.SupersedesLearningID.UUID()
		supersedesLearningID = &id
	}

	var reviewedBy *string
	if m.ReviewedBy.Valid {
		value := m.ReviewedBy.String()
		reviewedBy = &value
	}

	var reviewedAt *time.Time
	if m.ReviewedAt.Valid {
		t := m.ReviewedAt.Time()
		reviewedAt = &t
	}

	return ext.Learning{
		ID:                    m.ID.UUID(),
		Summary:               m.Summary.String(),
		Details:               m.Details.String(),
		Category:              m.Category.String(),
		Area:                  m.Area.String(),
		Status:                ext.LearningStatus(m.Status.String()),
		Priority:              ext.LearningPriority(m.Priority.String()),
		Confidence:            ext.LearningEvidenceLevel(m.Confidence.String()),
		ActionRequired:        m.ActionRequired,
		SourceType:            m.SourceType.String(),
		SourceRef:             m.SourceRef.String(),
		ProjectID:             projectID,
		RelatedThoughtID:      relatedThoughtID,
		RelatedSkillID:        relatedSkillID,
		ReviewedBy:            reviewedBy,
		ReviewedAt:            reviewedAt,
		DuplicateOfLearningID: duplicateOfLearningID,
		SupersedesLearningID:  supersedesLearningID,
		Tags:                  tags,
		CreatedAt:             m.CreatedAt.Time(),
		UpdatedAt:             m.UpdatedAt.Time(),
	}
}