package service

import (
	"fmt"
	"sync"

	"github.com/genex/translate-service/internal/domain/entity"
)

type TranslateService struct {
	// In-memory mapping store (production: PostgreSQL + Redis cache)
	mappings map[string]*entity.AddressMapping // keyed by internalAddress
	mu       sync.RWMutex
}

func NewTranslateService() *TranslateService {
	return &TranslateService{
		mappings: make(map[string]*entity.AddressMapping),
	}
}

func (s *TranslateService) CreateMapping(userID, internalAddr, chainAddr, chainType string) *entity.AddressMapping {
	s.mu.Lock()
	defer s.mu.Unlock()

	mapping := &entity.AddressMapping{
		ID:              fmt.Sprintf("map-%d", len(s.mappings)+1),
		UserID:          userID,
		InternalAddress: internalAddr,
		ChainAddress:    chainAddr,
		ChainType:       chainType,
		IsActive:        true,
	}
	s.mappings[internalAddr] = mapping
	return mapping
}

func (s *TranslateService) InternalToChain(internalAddr string) (*entity.AddressMapping, bool) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	m, ok := s.mappings[internalAddr]
	return m, ok
}

func (s *TranslateService) ChainToInternal(chainAddr string) (*entity.AddressMapping, bool) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	for _, m := range s.mappings {
		if m.ChainAddress == chainAddr && m.IsActive {
			return m, true
		}
	}
	return nil, false
}

func (s *TranslateService) GetByUserID(userID string) []*entity.AddressMapping {
	s.mu.RLock()
	defer s.mu.RUnlock()
	var result []*entity.AddressMapping
	for _, m := range s.mappings {
		if m.UserID == userID {
			result = append(result, m)
		}
	}
	return result
}