import { injectable } from 'inversify';
import { DashboardApiClient } from '@/lib/api/dashboard/DashboardApiClient';
import { AnalyticsApiClient } from '@/lib/api/analytics/AnalyticsApiClient';
import { DashboardOverviewDTO } from '@/lib/types/generated/DashboardOverviewDTO';
import { GetAnalyticsMetricsOutputDTO } from '@/lib/types/generated/GetAnalyticsMetricsOutputDTO';
import { Result } from '@/lib/contracts/Result';
import { DomainError, Service } from '@/lib/contracts/services/Service';
import { ConsoleErrorReporter } from '@/lib/infrastructure/logging/ConsoleErrorReporter';
import { ConsoleLogger } from '@/lib/infrastructure/logging/ConsoleLogger';
import { ApiError } from '@/lib/api/base/ApiError';
import { getWebsiteApiBaseUrl } from '@/lib/config/apiBaseUrl';

/**
 * DashboardService
 *
 * Pure service that creates its own API client and returns Result types.
 * No business logic, only data fetching and error mapping.
 */
@injectable()
export class DashboardService implements Service {
  private apiClient: DashboardApiClient;
  private analyticsApiClient: AnalyticsApiClient;

  constructor() {
    const baseUrl = getWebsiteApiBaseUrl();
    const errorReporter = new ConsoleErrorReporter();
    const logger = new ConsoleLogger();
    this.apiClient = new DashboardApiClient(baseUrl, errorReporter, logger);
    this.analyticsApiClient = new AnalyticsApiClient(baseUrl, errorReporter, logger);
  }

  async getDashboardOverview(): Promise<Result<DashboardOverviewDTO, DomainError>> {
    try {
      const dto = await this.apiClient.getDashboardOverview();
      return Result.ok(dto);
    } catch (error) {
      return this.handleError(error, 'Dashboard fetch failed');
    }
  }

  async getAnalyticsMetrics(): Promise<Result<GetAnalyticsMetricsOutputDTO, DomainError>> {
    try {
      const dto = await this.analyticsApiClient.getAnalyticsMetrics();
      return Result.ok(dto);
    } catch (error) {
      return this.handleError(error, 'Analytics metrics fetch failed');
    }
  }

  private handleError(error: unknown, defaultMessage: string): Result<any, DomainError> {
    if (error instanceof ApiError) {
      switch (error.type) {
        case 'NOT_FOUND':
          return Result.err({ type: 'notFound', message: error.message });
        case 'AUTH_ERROR':
          return Result.err({ type: 'unauthorized', message: error.message });
        case 'SERVER_ERROR':
          return Result.err({ type: 'serverError', message: error.message });
        case 'NETWORK_ERROR':
        case 'TIMEOUT_ERROR':
          return Result.err({ type: 'networkError', message: error.message });
        default:
          return Result.err({ type: 'unknown', message: error.message });
      }
    }
    
    if (error instanceof Error) {
      return Result.err({ type: 'unknown', message: error.message });
    }
    
    return Result.err({ type: 'unknown', message: defaultMessage });
  }
}