class ConsoleAPIClient {
  constructor() {
    this.baseURL = 'https://api.weir.ai';
    this.accessToken = null;
    this.refreshToken = null;
  }
  
  async login(username, password) {
    const response = await fetch(`${this.baseURL}/auth/login`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ username, password })
    });
    
    const data = await response.json();
    this.accessToken = data.data.accessToken;
    this.refreshToken = data.data.refreshToken;
    
    return data;
  }
  
  async refreshAccessToken() {
    const response = await fetch(`${this.baseURL}/auth/refresh/token`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ refreshToken: this.refreshToken })
    });
    
    const data = await response.json();
    this.accessToken = data.data.accessToken;
    this.refreshToken = data.data.refreshToken;
    
    return data;
  }
  
  getHeaders() {
    return {
      'Authorization': `Bearer ${this.accessToken}`,
      'Content-Type': 'application/json',
      'x-source': 'console'
    };
  }
}

class ConsoleAPIError extends Error {
  constructor(message, code, details, status) {
    super(message);
    this.name = 'ConsoleAPIError';
    this.code = code;
    this.details = details;
    this.status = status;
  }
}

class ConsoleAPIClient {
  async makeRequest(url, options = {}) {
    try {
      const response = await fetch(url, {
        ...options,
        headers: {
          ...this.getHeaders(),
          ...options.headers
        }
      });
      
      if (!response.ok) {
        const errorData = await response.json();
        throw new ConsoleAPIError(
          errorData.error?.message || 'API request failed',
          errorData.error?.code || 'UNKNOWN_ERROR',
          errorData.error?.details,
          response.status
        );
      }
      
      return await response.json();
    } catch (error) {
      if (error instanceof ConsoleAPIError) {
        throw error;
      }
      
      // Handle network errors
      if (error.name === 'TypeError' && error.message.includes('fetch')) {
        throw new ConsoleAPIError(
          'Network error: Unable to connect to API',
          'NETWORK_ERROR',
          null,
          0
        );
      }
      
      throw new ConsoleAPIError(
        'Unexpected error occurred',
        'UNEXPECTED_ERROR',
        error.message,
        0
      );
    }
  }
}

class RateLimitedClient {
  constructor(apiClient, requestsPerMinute = 200) {
    this.apiClient = apiClient;
    this.requestsPerMinute = requestsPerMinute;
    this.requestQueue = [];
    this.requestCount = 0;
    this.windowStart = Date.now();
    
    setInterval(() => {
      this.requestCount = 0;
      this.windowStart = Date.now();
      this.processQueue();
    }, 60000);
  }
  
  async makeRequest(url, options = {}) {
    return new Promise((resolve, reject) => {
      this.requestQueue.push({ url, options, resolve, reject });
      this.processQueue();
    });
  }
  
  async processQueue() {
    if (this.requestQueue.length === 0 || this.requestCount >= this.requestsPerMinute) {
      return;
    }
    
    const request = this.requestQueue.shift();
    this.requestCount++;
    
    try {
      const result = await this.apiClient.makeRequest(request.url, request.options);
      request.resolve(result);
    } catch (error) {
      if (error.status === 429) {
        // Rate limited, put request back in queue
        this.requestQueue.unshift(request);
        setTimeout(() => this.processQueue(), 60000);
      } else {
        request.reject(error);
      }
    }
  }
}

class ManagementDashboard {
  constructor() {
    this.apiClient = new ConsoleAPIClient();
    this.teamManager = new TeamManager(this.apiClient);
    this.platformManager = new PlatformManager(this.apiClient);
    this.userManager = new UserManager(this.apiClient);
    
    this.teamDashboard = new TeamDashboard(this.teamManager);
    this.platformDashboard = new PlatformDashboard(this.platformManager);
    this.userProfileManager = new UserProfileManager(this.userManager);
  }
  
  async initialize() {
    try {
      // Load initial data
      await Promise.all([
        this.teamDashboard.loadTeams(),
        this.platformDashboard.loadPlatforms(),
        this.userProfileManager.loadProfile()
      ]);
      
      this.setupEventListeners();
    } catch (error) {
      console.error('Failed to initialize dashboard:', error);
    }
  }
  
  setupEventListeners() {
    // Setup navigation and form handlers
    document.getElementById('create-team-btn').addEventListener('click', () => {
      this.showCreateTeamModal();
    });
    
    document.getElementById('create-platform-btn').addEventListener('click', () => {
      this.showCreatePlatformModal();
    });
  }
  
  showCreateTeamModal() {
    const modal = document.getElementById('create-team-modal');
    modal.style.display = 'block';
    
    document.getElementById('team-form').addEventListener('submit', async (e) => {
      e.preventDefault();
      const name = document.getElementById('team-name').value;
      
      try {
        await this.teamDashboard.createTeam(name);
        modal.style.display = 'none';
        document.getElementById('team-form').reset();
      } catch (error) {
        alert('Failed to create team. Please try again.');
      }
    });
  }
  
  showCreatePlatformModal() {
    const modal = document.getElementById('create-platform-modal');
    modal.style.display = 'block';
    
    document.getElementById('platform-form').addEventListener('submit', async (e) => {
      e.preventDefault();
      const platformData = {
        name: document.getElementById('platform-name').value,
        teamId: document.getElementById('team-id').value,
        description: document.getElementById('platform-description').value,
        type: document.getElementById('platform-type').value,
        domain: document.getElementById('platform-domain').value
      };
      
      try {
        await this.platformDashboard.createPlatform(platformData);
        modal.style.display = 'none';
        document.getElementById('platform-form').reset();
      } catch (error) {
        alert('Failed to create platform. Please try again.');
      }
    });
  }
}

// Initialize dashboard when page loads
document.addEventListener('DOMContentLoaded', async () => {
  const dashboard = new ManagementDashboard();
  await dashboard.initialize();
});