import axios from 'axios';
import { createLogger } from '../../utils/logger';

const logger = createLogger('VirtualNumberService');

export interface Country {
    id: string;
    name: string;
    count: number;
}

export interface PriceInfo {
    cost: number;
    count: number;
    rate?: number;
}

export interface ServicePrice {
    [country: string]: {
        [operator: string]: PriceInfo;
    };
}

export interface ProductPrices {
    [service: string]: {
        [country: string]: {
            [operator: string]: PriceInfo;
        };
    };
}

export interface MaxPrice {
    id: number;
    product: string;
    price: number;
    CreatedAt: string; // date string
}

export class VirtualNumberService {
    private static instance: VirtualNumberService;
    private apiKey: string;
    private baseUrl: string = 'https://5sim.net/v1';
    
    private constructor() {
        this.apiKey = process.env.FIVESIM_API_KEY || '';
        if (!this.apiKey) {
            logger.error('5sim API key not found in environment variables');
        }
    }

    public static getInstance(): VirtualNumberService {
        if (!VirtualNumberService.instance) {
            VirtualNumberService.instance = new VirtualNumberService();
        }
        return VirtualNumberService.instance;
    }

    /**
     * Get available countries for a specific service
     */
    async getAvailableCountries(service: string): Promise<Country[]> {
        try {
            const response = await axios.get(`${this.baseUrl}/guest/countries/${service}`, {
                headers: {
                    'Authorization': `Bearer ${this.apiKey}`,
                    'Accept': 'application/json',
                }
            });
            
            return response.data;
        } catch (error: any) {
            logger.error(`Error fetching countries for ${service}: ${error.message}`);
            throw new Error(`Failed to fetch available countries: ${error.message}`);
        }
    }

    /**
     * Get all prices for a specific product
     */
    async getProductPrices(product: string): Promise<ProductPrices> {
        try {
            const response = await axios.get(`${this.baseUrl}/guest/prices?product=${product}`, {
                headers: {
                    'Accept': 'application/json',
                }
            });
            
            return response.data;
        } catch (error: any) {
            logger.error(`Error fetching prices for product ${product}: ${error.message}`);
            throw new Error(`Failed to fetch product prices: ${error.message}`);
        }
    }

    /**
     * Get prices for a specific service and country
     */
    async getPrices(service: string, country: string): Promise<ServicePrice> {
        try {
            const response = await axios.get(`${this.baseUrl}/guest/prices?product=${service}&country=${country}`, {
                headers: {
                    'Authorization': `Bearer ${this.apiKey}`,
                    'Accept': 'application/json',
                }
            });
            
            return response.data;
        } catch (error: any) {
            logger.error(`Error fetching prices for ${service} in ${country}: ${error.message}`);
            throw new Error(`Failed to fetch prices: ${error.message}`);
        }
    }

    /**
     * Purchase a number for a specific service and country
     */
    async purchaseNumber(service: string, country: string, operator: string): Promise<any> {
        try {
            const response = await axios.get(
                `${this.baseUrl}/user/buy/activation/${country}/${operator}/${service}`, 
                {
                    headers: {
                        'Authorization': `Bearer ${this.apiKey}`,
                        'Accept': 'application/json',
                    }
                }
            );
            
            return response.data;
        } catch (error: any) {
            logger.error(`Error purchasing number for ${service} in ${country}: ${error.message}`);
            throw new Error(`Failed to purchase number: ${error.message}`);
        }
    }

    /**
     * Check for SMS received for a specific order
     */
    async checkSMS(orderId: string | number): Promise<any> {
        try {
            const response = await axios.get(
                `${this.baseUrl}/user/check/${orderId}`, 
                {
                    headers: {
                        'Authorization': `Bearer ${this.apiKey}`,
                        'Accept': 'application/json',
                    }
                }
            );
            
            return response.data;
        } catch (error: any) {
            logger.error(`Error checking SMS for order ${orderId}: ${error.message}`);
            throw new Error(`Failed to check SMS: ${error.message}`);
        }
    }

    /**
     * Get a list of established price limits.
     */
    async getMaxPrices(): Promise<MaxPrice[]> {
        try {
            const response = await axios.get(`${this.baseUrl}/user/max-prices`, {
                headers: {
                    'Authorization': `Bearer ${this.apiKey}`,
                    'Accept': 'application/json',
                }
            });
            
            return response.data;
        } catch (error: any) {
            logger.error(`Error fetching max prices: ${error.message}`);
            throw new Error(`Failed to fetch max prices: ${error.message}`);
        }
    }
}