package issuereporting

import (
	"context"
	"errors"

	dbgen "Yimaru-Backend/gen/db"
	"Yimaru-Backend/internal/domain"
	"Yimaru-Backend/internal/repository"
)

type Service struct {
	repo repository.ReportedIssueRepository
}

func New(repo repository.ReportedIssueRepository) *Service {
	return &Service{repo: repo}
}

func (s *Service) CreateReportedIssue(ctx context.Context, issue domain.ReportedIssueReq, userID int64, role domain.Role) (domain.ReportedIssue, error) {

	// metadata, err := json.Marshal(issue.Metadata)
	// if err != nil {
	// 	return domain.ReportedIssue{}, err
	// }
	params := dbgen.CreateReportedIssueParams{
		UserID:      userID,
		UserRole:    string(role),
		Subject:     issue.Subject,
		Description: issue.Description,
		IssueType:   string(issue.IssueType),
		// Metadata:    metadata,
	}
	dbIssue, err := s.repo.CreateReportedIssue(ctx, params)
	if err != nil {
		return domain.ReportedIssue{}, err
	}
	// Map dbgen.ReportedIssue to domain.ReportedIssue
	reportedIssue := domain.ReportedIssue{
		ID:          dbIssue.ID,
		Subject:     dbIssue.Subject,
		Description: dbIssue.Description,
		UserID:      dbIssue.UserID,
		UserRole:    domain.Role(dbIssue.UserRole),
		Status:      domain.ReportedIssueStatus(dbIssue.Status),
		IssueType:   domain.ReportedIssueType(dbIssue.IssueType),
		CreatedAt:   dbIssue.CreatedAt.Time,
		UpdatedAt:   dbIssue.UpdatedAt.Time,

		// Add other fields as necessary
	}
	return reportedIssue, nil
}

func (s *Service) GetIssuesForUser(ctx context.Context, userID int64, limit, offset int) ([]domain.ReportedIssue, error) {
	dbIssues, err := s.repo.ListReportedIssuesByUser(ctx, userID, int32(limit), int32(offset))
	if err != nil {
		return nil, err
	}
	reportedIssues := make([]domain.ReportedIssue, len(dbIssues))
	for i, dbIssue := range dbIssues {
		reportedIssues[i] = domain.ReportedIssue{
			ID:          dbIssue.ID,
			Subject:     dbIssue.Subject,
			Description: dbIssue.Description,
			UserID:      dbIssue.UserID,
			UserRole:    domain.Role(dbIssue.UserRole),
			Status:      domain.ReportedIssueStatus(dbIssue.Status),
			IssueType:   domain.ReportedIssueType(dbIssue.IssueType),
			CreatedAt:   dbIssue.CreatedAt.Time,
			UpdatedAt:   dbIssue.UpdatedAt.Time,
			// Add other fields as necessary
		}
	}
	return reportedIssues, nil
}

func (s *Service) GetAllIssues(ctx context.Context, limit, offset int) ([]dbgen.ReportedIssue, error) {
	return s.repo.ListReportedIssues(ctx, int32(limit), int32(offset))
}

func (s *Service) UpdateIssueStatus(ctx context.Context, issueID int64, status string) error {
	validStatuses := map[string]bool{"pending": true, "in_progress": true, "resolved": true, "rejected": true}
	if !validStatuses[status] {
		return errors.New("invalid status")
	}
	return s.repo.UpdateReportedIssueStatus(ctx, issueID, status)
}

func (s *Service) DeleteIssue(ctx context.Context, issueID int64) error {
	return s.repo.DeleteReportedIssue(ctx, issueID)
}