import {
    BatteryResponse,
    HeightResponse,
    TemperatureResponse,
    SpeedResponse,
    TimeResponse,
    WifiResponse,
    AttitudeResponse,
    BarometerResponse,
    AccelerationResponse,
    TofResponse,
    ResponseParser
} from './types';

/**
 * Parse battery level string to structured response
 */
export const parseBattery: ResponseParser<BatteryResponse> = (batteryStr: string) => {
    const value = parseInt(batteryStr, 10);
    return { value };
};

/**
 * Parse height string to structured response
 */
export const parseHeight: ResponseParser<HeightResponse> = (heightStr: string) => {
    const value = parseInt(heightStr.replace('dm', ''), 10);
    return { value, unit: 'dm' };
};

/**
 * Parse temperature string to structured response
 */
export const parseTemperature: ResponseParser<TemperatureResponse> = (tempStr: string) => {
    const match = tempStr.match(/(\d+)~(\d+)C/);
    if (match && match.length >= 3) {
        return {
            min: parseInt(match[1], 10),
            max: parseInt(match[2], 10),
            unit: '°C'
        };
    }
    return { min: 0, max: 0, unit: '°C' };
};

/**
 * Parse speed string to structured response
 */
export const parseSpeed: ResponseParser<SpeedResponse> = (speedStr: string) => {
    const value = parseFloat(speedStr);
    return { value, unit: 'cm/s' };
};

/**
 * Parse time string to structured response
 */
export const parseTime: ResponseParser<TimeResponse> = (timeStr: string) => {
    const value = parseInt(timeStr.replace('s', ''), 10);
    return { value, unit: 's' };
};

/**
 * Parse wifi signal strength to structured response
 */
export const parseWifi: ResponseParser<WifiResponse> = (wifiStr: string) => {
    const value = parseInt(wifiStr, 10);
    return { value, unit: '%' };
};

/**
 * Parse attitude string to structured response
 */
export const parseAttitude: ResponseParser<AttitudeResponse> = (attitudeStr: string) => {
    const parts = attitudeStr.split(';');
    const result: AttitudeResponse = { pitch: 0, roll: 0, yaw: 0, unit: '°' };
    
    parts.forEach(part => {
        if (part.includes('pitch:')) {
            result.pitch = parseInt(part.replace('pitch:', ''), 10);
        } else if (part.includes('roll:')) {
            result.roll = parseInt(part.replace('roll:', ''), 10);
        } else if (part.includes('yaw:')) {
            result.yaw = parseInt(part.replace('yaw:', ''), 10);
        }
    });
    
    return result;
};

/**
 * Parse barometer string to structured response
 */
export const parseBarometer: ResponseParser<BarometerResponse> = (baroStr: string) => {
    const value = parseFloat(baroStr);
    return { value, unit: 'm' };
};

/**
 * Parse acceleration string to structured response
 */
export const parseAcceleration: ResponseParser<AccelerationResponse> = (accelStr: string) => {
    const parts = accelStr.split(';');
    const result: AccelerationResponse = { x: 0, y: 0, z: 0, unit: 'mG' };
    
    parts.forEach(part => {
        if (part.includes('agx:')) {
            result.x = parseFloat(part.replace('agx:', ''));
        } else if (part.includes('agy:')) {
            result.y = parseFloat(part.replace('agy:', ''));
        } else if (part.includes('agz:')) {
            result.z = parseFloat(part.replace('agz:', ''));
        }
    });
    
    return result;
};

/**
 * Parse ToF (Time of Flight) string to structured response
 */
export const parseTof: ResponseParser<TofResponse> = (tofStr: string) => {
    const value = parseInt(tofStr.replace('mm', ''), 10);
    return { value, unit: 'mm' };
};

/**
 * Parse boolean command response
 * Returns true for "ok", false for any other response
 */
export const parseCommandResponse: ResponseParser<boolean> = (response: string) => {
    return response.trim().toLowerCase() === "ok";
};