// UserService.ts
import axios from 'axios';
import { Stripe } from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

export class UserService {
  async createUser(email: string, password: string) {
    const user = await db.users.create({ email, password });
    
    // ❌ Acoplamento direto
    await stripe.customers.create({
      email: user.email,
      name: user.name
    });
    
    await axios.post('https://api.sendgrid.com/v3/mail/send', {
      to: user.email,
      subject: 'Welcome'
    });
    
    return user;
  }
}

// application/ports/PaymentGateway.ts
export interface PaymentGateway {
  createCustomer(data: { email: string; name: string }): Promise<{ id: string }>;
}

// application/ports/EmailService.ts
export interface EmailService {
  send(data: { to: string; subject: string; body: string }): Promise<void>;
}

// infrastructure/adapters/StripePaymentGateway.ts
import { Stripe } from 'stripe';
import { PaymentGateway } from '../../application/ports/PaymentGateway';

export class StripePaymentGateway implements PaymentGateway {
  constructor(private stripe: Stripe) {}
  
  async createCustomer(data: { email: string; name: string }) {
    const customer = await this.stripe.customers.create(data);
    return { id: customer.id };
  }
}

// infrastructure/adapters/SendGridEmailService.ts
import sgMail from '@sendgrid/mail';
import { EmailService } from '../../application/ports/EmailService';

export class SendGridEmailService implements EmailService {
  constructor() {
    sgMail.setApiKey(process.env.SENDGRID_API_KEY!);
  }
  
  async send(data: { to: string; subject: string; body: string }) {
    await sgMail.send({ to: data.to, from: 'noreply@app.com', subject: data.subject, html: data.body });
  }
}

// application/services/UserService.ts
export class UserService {
  constructor(
    private userRepository: UserRepository,
    private paymentGateway: PaymentGateway,
    private emailService: EmailService
  ) {}
  
  async createUser(data: CreateUserData) {
    const user = await this.userRepository.create(data);
    
    await this.paymentGateway.createCustomer({
      email: user.email,
      name: user.name
    });
    
    await this.emailService.send({
      to: user.email,
      subject: 'Welcome',
      body: '<h1>Welcome</h1>'
    });
    
    return user;
  }
}

// infrastructure/composition.ts
import { UserService } from '../application/services/UserService';
import { PostgresUserRepository } from './adapters/PostgresUserRepository';
import { StripePaymentGateway } from './adapters/StripePaymentGateway';
import { SendGridEmailService } from './adapters/SendGridEmailService';
import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);

export const userService = new UserService(
  new PostgresUserRepository(),
  new StripePaymentGateway(stripe),
  new SendGridEmailService()
);

// application/hooks/useUserProfile.ts
export function useUserProfile(userId: string) {
  const [user, setUser] = useState<User | null>(null);
  
  useEffect(() => {
    userService.getProfile(userId).then(setUser);
  }, [userId]);
  
  return user;
}

const UserServiceContext = createContext<UserService | null>(null);

export function UserServiceProvider({ userService, children }: Props) {
  return (
    <UserServiceContext.Provider value={userService}>
      {children}
    </UserServiceContext.Provider>
  );
}

export function useUserService() {
  const service = useContext(UserServiceContext);
  if (!service) throw new Error('UserServiceProvider required');
  return service;
}