// amplify/backend/auth/cognitoConfig.js
export const cognitoConfig = {
  userPoolConfig: {
    userPoolName: 'landing-page-users',
    passwordPolicy: {
      minimumLength: 8,
      requireLowercase: true,
      requireUppercase: true,
      requireNumbers: true,
      requireSymbols: true
    },
    signupAttributes: ['email', 'name', 'phone_number'],
    autoVerifiedAttributes: ['email'],
    mfaConfiguration: 'OFF',
  },
  webClientConfig: {
    clientName: 'landing-page-client',
    generateSecret: false,
    refreshTokenValidity: 30,
    accessTokenValidity: 1,
    idTokenValidity: 1,
    preventUserExistenceErrors: true
  }
};

// amplify/backend/api/schema.graphql
type User @model @auth(rules: [{allow: owner}]) {
  id: ID!
  email: String!
  name: String!
  phone: String
  createdAt: AWSDateTime!
  updatedAt: AWSDateTime!
}

// amplify/backend/api/landingPageAPI/dynamodb-config.js
export const tableConfig = {
  UserTable: {
    tableName: 'User-${env}',
    partitionKey: {
      name: 'id',
      type: 'S'
    },
    sortKey: {
      name: 'email',
      type: 'S'
    },
    gsi1: {
      name: 'StatusIndex',
      partitionKey: {
        name: 'status',
        type: 'S'
      },
      sortKey: {
        name: 'createdAt',
        type: 'S'
      }
    },
    gsi2: {
      name: 'EmailIndex',
      partitionKey: {
        name: 'email',
        type: 'S'
      }
    },
    ttl: {
      attributeName: 'ttl',
      enabled: true
    },
    stream: {
      enabled: true,
      viewType: 'NEW_AND_OLD_IMAGES'
    },
    billingMode: 'PAY_PER_REQUEST',
    pointInTimeRecovery: true,
    encryption: 'AWS_OWNED_KMS_KEY',
    tags: {
      Environment: '${env}',
      Project: 'LandingPage'
    }
  }
}

// amplify/backend/api/landingPageAPI/resolvers/Mutation.registerUser.js
export const handler = async (event) => {
  const { arguments, identity } = event;
  const { input } = arguments;
  
  try {
    // Validar input
    if (!input.email || !input.name) {
      throw new Error('Email and name are required');
    }
    
    // Crear usuario en DynamoDB
    const user = {
      id: uuid(),
      email: input.email.toLowerCase(),
      name: input.name,
      phoneNumber: input.phoneNumber,
      address: input.address,
      interests: input.interests || [],
      status: 'PENDING',
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString()
    };
    
    const params = {
      TableName: process.env.USER_TABLE,
      Item: user,
      ConditionExpression: 'attribute_not_exists(email)'
    };
    
    await dynamoDB.put(params).promise();
    
    // Disparar eventos y notificaciones
    await publishToEventBridge({
      detailType: 'UserRegistered',
      detail: { userId: user.id, email: user.email }
    });
    
    return user;
  } catch (error) {
    console.error('Error registering user:', error);
    throw error;
  }
};

// amplify/backend/api/landingPageAPI/resolvers/Query.getUsersByStatus.js
export const handler = async (event) => {
  const { arguments } = event;
  const { status } = arguments;
  
  try {
    const params = {
      TableName: process.env.USER_TABLE,
      IndexName: 'StatusIndex',
      KeyConditionExpression: '#status = :status',
      ExpressionAttributeNames: {
        '#status': 'status'
      },
      ExpressionAttributeValues: {
        ':status': status
      }
    };
    
    const result = await dynamoDB.query(params).promise();
    return result.Items;
  } catch (error) {
    console.error('Error getting users by status:', error);
    throw error;
  }
};

// src/hooks/useForm.js
import { useState } from 'react';

export function useForm({ initialValues, onSubmit, validate }) {
  const [values, setValues] = useState(initialValues);
  const [errors, setErrors] = useState({});
  const [touched, setTouched] = useState({});
  const [isSubmitting, setIsSubmitting] = useState(false);

  const handleChange = (event) => {
    const { name, value } = event.target;
    
    // Manejar campos anidados (e.g., address.street)
    if (name.includes('.')) {
      const [parent, child] = name.split('.');
      setValues(prev => ({
        ...prev,
        [parent]: {
          ...prev[parent],
          [child]: value
        }
      }));
    } else {
      setValues(prev => ({
        ...prev,
        [name]: value
      }));
    }

    // Validar campo cuando cambia
    if (validate) {
      const fieldError = validate({ [name]: value });
      setErrors(prev => ({
        ...prev,
        [name]: fieldError?.[name]
      }));
    }
  };

  const handleBlur = (event) => {
    const { name } = event.target;
    setTouched(prev => ({
      ...prev,
      [name]: true
    }));
  };

  const handleSubmit = async (event) => {
    event.preventDefault();
    
    setIsSubmitting(true);

    // Validar todo el formulario
    if (validate) {
      const formErrors = validate(values);
      setErrors(formErrors);
      if (Object.keys(formErrors).length > 0) {
        setIsSubmitting(false);
        return;
      }
    }

    try {
      await onSubmit(values);
      // Resetear formulario después de envío exitoso
      setValues(initialValues);
      setTouched({});
      setErrors({});
    } catch (error) {
      setErrors(prev => ({
        ...prev,
        submit: error.message
      }));
    } finally {
      setIsSubmitting(false);
    }
  };

  return {
    values,
    errors,
    touched,
    isSubmitting,
    handleChange,
    handleBlur,
    handleSubmit
  };
}

// src/utils/validators.js
export const validateEmail = (email) => {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  if (!email) return 'El correo es requerido';
  if (!emailRegex.test(email)) return 'El correo no es válido';
  return null;
};

export const validatePhone = (phone) => {
  const phoneRegex = /^\+?[\d\s-]{10,}$/;
  if (phone && !phoneRegex.test(phone)) {
    return 'El número de teléfono no es válido';
  }
  return null;
};

export const validatePostalCode = (code, country) => {
  const postalRegexByCountry = {
    US: /^\d{5}(-\d{4})?$/,
    MX: /^\d{5}$/,
    ES: /^\d{5}$/,
  };

  if (code && postalRegexByCountry[country]) {
    if (!postalRegexByCountry[country].test(code)) {
      return 'Código postal no válido para el país seleccionado';
    }
  }
  return null;
};

export const validateRegistrationForm = (values) => {
  const errors = {};

  // Validar nombre
  if (!values.name) {
    errors.name = 'El nombre es requerido';
  } else if (values.name.length < 2) {
    errors.name = 'El nombre debe tener al menos 2 caracteres';
  }

  // Validar email
  const emailError = validateEmail(values.email);
  if (emailError) errors.email = emailError;

  // Validar teléfono
  if (values.phoneNumber) {
    const phoneError = validatePhone(values.phoneNumber);
    if (phoneError) errors.phoneNumber = phoneError;
  }

  // Validar dirección
  if (values.address) {
    if (values.address.zipCode && values.address.country) {
      const postalError = validatePostalCode(values.address.zipCode, values.address.country);
      if (postalError) errors['address.zipCode'] = postalError;
    }
  }

  return errors;
};

// src/graphql/mutations.js
import { graphql } from '@aws-amplify/api-graphql';

export const registerUser = /* GraphQL */ `
  mutation RegisterUser($input: RegisterUserInput!) {
    registerUser(input: $input) {
      id
      email
      name
      phoneNumber
      address {
        street
        city
        state
        country
        zipCode
      }
      interests
      status
      createdAt
      updatedAt
    }
  }
`;

// src/services/UserService.js
import { API, graphqlOperation } from 'aws-amplify';
import * as mutations from '../graphql/mutations';
import * as queries from '../graphql/queries';

export class UserService {
  static async registerUser(userData) {
    try {
      const { data } = await API.graphql(
        graphqlOperation(mutations.registerUser, { input: userData })
      );
      return data.registerUser;
    } catch (error) {
      console.error('Error registering user:', error);
      throw new Error('Error al registrar usuario. Por favor intente nuevamente.');
    }
  }

  static async getUsersByStatus(status) {
    try {
      const { data } = await API.graphql(
        graphqlOperation(queries.getUsersByStatus, { status })
      );
      return data.getUsersByStatus;
    } catch (error) {
      console.error('Error fetching users:', error);
      throw new Error('Error al obtener usuarios.');
    }
  }
}

// src/services/StorageService.js
import { Storage } from 'aws-amplify';
import { v4 as uuid } from 'uuid';

export class StorageService {
  static async uploadProfilePicture(file, userId) {
    try {
      const extension = file.name.split('.').pop();
      const key = `profiles/${userId}/${uuid()}.${extension}`;
      
      const result = await Storage.put(key, file, {
        contentType: file.type,
        metadata: {
          userId,
          uploadDate: new Date().toISOString()
        }
      });

      const url = await Storage.get(key);
      return url;
    } catch (error) {
      console.error('Error uploading file:', error);
      throw new Error('Error al subir la imagen. Por favor intente nuevamente.');
    }
  }

  static async deleteProfilePicture(key) {
    try {
      await Storage.remove(key);
    } catch (error) {
      console.error('Error deleting file:', error);
      throw new Error('Error al eliminar la imagen.');
    }
  }
}

// Configuración de S3 en Amplify
export const storageConfig = {
  Storage: {
    AWSS3: {
      bucket: 'user-profile-pictures-${env}',
      region: process.env.REGION,
      uploadTimeout: 300000
    }
  }
};

// src/services/NotificationService.js
import { SNS } from 'aws-sdk';
import { getUserPreferences } from './UserPreferencesService';

export class NotificationService {
  constructor() {
    this.sns = new SNS({
      region: process.env.REGION,
      apiVersion: '2010-03-31'
    });
  }

  async sendWelcomeNotification(userId, email) {
    try {
      const params = {
        Message: JSON.stringify({
          default: `Nuevo usuario registrado: ${email}`,
          email: `
            <h2>¡Bienvenido a nuestra plataforma!</h2>
            <p>Gracias por registrarte. Tu cuenta ha sido creada exitosamente.</p>
            <p>Por favor verifica tu correo electrónico para activar todas las funcionalidades.</p>
          `,
          sms: `Bienvenido a nuestra plataforma. Por favor verifica tu correo electrónico.`
        }),
        MessageStructure: 'json',
        TopicArn: process.env.WELCOME_NOTIFICATION_TOPIC_ARN
      };

      await this.sns.publish(params).promise();
    } catch (error) {
      console.error('Error sending welcome notification:', error);
    }
  }

  async sendAdminNotification(eventType, data) {
    try {
      const params = {
        Message: JSON.stringify({
          eventType,
          data,
          timestamp: new Date().toISOString()
        }),
        TopicArn: process.env.ADMIN_NOTIFICATION_TOPIC_ARN
      };

      await this.sns.publish(params).promise();
    } catch (error) {
      console.error('Error sending admin notification:', error);
    }
  }
}

// src/services/MonitoringService.js
import { CloudWatch } from 'aws-sdk';

export class MonitoringService {
  constructor() {
    this.cloudWatch = new CloudWatch({
      region: process.env.REGION,
      apiVersion: '2010-08-01'
    });
  }

  async logRegistrationMetrics(success, duration) {
    try {
      const metrics = [
        {
          MetricName: 'UserRegistrationAttempt',
          Value: 1,
          Unit: 'Count',
          Dimensions: [
            {
              Name: 'Status',
              Value: success ? 'Success' : 'Failure'
            }
          ]
        },
        {
          MetricName: 'RegistrationDuration',
          Value: duration,
          Unit: 'Milliseconds',
          Dimensions: [
            {
              Name: 'Operation',
              Value: 'UserRegistration'
            }
          ]
        }
      ];

      await this.cloudWatch.putMetricData({
        Namespace: 'LandingPage/UserRegistration',
        MetricData: metrics
      }).promise();
    } catch (error) {
      console.error('Error logging metrics:', error);
    }
  }

  async trackAPILatency(operation, duration) {
    try {
      await this.cloudWatch.putMetricData({
        Namespace: 'LandingPage/API',
        MetricData: [{
          MetricName: 'OperationLatency',
          Value: duration,
          Unit: 'Milliseconds',
          Dimensions: [
            {
              Name: 'Operation',
              Value: operation
            }
          ]
        }]
      }).promise();
    } catch (error) {
      console.error('Error tracking API latency:', error);
    }
  }
}

// Middleware para tracking
export const trackingMiddleware = store => next => action => {
  const start = Date.now();
  const result = next(action);
  const duration = Date.now() - start;

  if (action.type.startsWith('api/')) {
    const monitoring = new MonitoringService();
    monitoring.trackAPILatency(action.type, duration);
  }

  return result;
};

// tests/unit/RegisterForm.test.js
import { render, screen, fireEvent, waitFor } from '@testing-library/react';
import { RegisterForm } from '../../src/components/RegisterForm';
import { UserService } from '../../src/services/UserService';
import '@testing-library/jest-dom';

jest.mock('../../src/services/UserService');

describe('RegisterForm', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  test('renders form fields correctly', () => {
    render(<RegisterForm />);
    
    expect(screen.getByLabelText(/nombre completo/i)).toBeInTheDocument();
    expect(screen.getByLabelText(/correo electrónico/i)).toBeInTheDocument();
    expect(screen.getByLabelText(/teléfono/i)).toBeInTheDocument();
    expect(screen.getByRole('button', { name: /registrarse/i })).toBeInTheDocument();
  });

  test('validates required fields', async () => {
    render(<RegisterForm />);
    
    fireEvent.click(screen.getByRole('button', { name: /registrarse/i }));

    await waitFor(() => {
      expect(screen.getByText(/el nombre es requerido/i)).toBeInTheDocument();
      expect(screen.getByText(/el correo es requerido/i)).toBeInTheDocument();
    });
  });

  test('submits form successfully', async () => {
    UserService.registerUser.mockResolvedValueOnce({
      id: '123',
      email: 'test@example.com',
      name: 'Test User'
    });

    render(<RegisterForm />);

    fireEvent.change(screen.getByLabelText(/nombre completo/i), {
      target: { value: 'Test User' }
    });
    fireEvent.change(screen.getByLabelText(/correo electrónico/i), {
      target: { value: 'test@example.com' }
    });
    fireEvent.change(screen.getByLabelText(/teléfono/i), {
      target: { value: '+1234567890' }
    });

    fireEvent.click(screen.getByRole('button', { name: /registrarse/i }));

    await waitFor(() => {
      expect(UserService.registerUser).toHaveBeenCalledWith({
        name: 'Test User',
        email: 'test@example.com',
        phoneNumber: '+1234567890'
      });
    });
  });
});

// tests/integration/registration.test.js
import { test, expect } from '@playwright/test';

test.describe('Registration Flow', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/register');
  });

  test('complete registration process', async ({ page }) => {
    await page.fill('[name="name"]', 'Integration Test User');
    await page.fill('[name="email"]', 'test@integration.com');
    await page.fill('[name="phoneNumber"]', '+1234567890');

    await page.click('button[type="submit"]');

    await expect(page.locator('.success-message')).toBeVisible();
    await expect(page.locator('.success-message')).toContainText('registro exitoso');
  });

  test('handles validation errors', async ({ page }) => {
    await page.fill('[name="email"]', 'invalid-email');
    await page.click('button[type="submit"]');

    await expect(page.locator('.error-message')).toBeVisible();
    await expect(page.locator('.error-message')).toContainText('correo no es válido');
  });
});