err += (var * (*coeff as i64) / COEFF_MUL) as i32;

fn adc_val(&self, val: u16) -> u16 {
    let val = self.line.adc_val(val);

    let err = if val == 0 {
        0
    } else {
        let mut var = 1i64;
        let mut err = (var * self.coeff[0] / COEFF_MUL) as i32;

        for coeff in &self.coeff[1..] {
            var *= val as i64;
            err += (var * (*coeff as i64) / COEFF_MUL) as i32; // overflow happens here
        }

        err
    };

    (val as i32 - err) as u16
}

for i in 0..4096 {
    info!(
        "Raw value: {:?}, Converted Value: {:?}",
        i,
        self.calibration.adc_val(i) // triggers the overflow
    );
}

pub struct RawPins {
    pub in1: GpioPin<4>,
    pub in2: GpioPin<5>,
    pub in3: GpioPin<6>,
    pub in4: GpioPin<7>,
    pub in5: GpioPin<8>,
    pub in6: GpioPin<3>,
    pub in7: GpioPin<9>,
    pub in8: GpioPin<10>,
}

pub struct AdcPins {
    pub in1: AdcPin<GpioPin<4>, ADC1>,
    pub in2: AdcPin<GpioPin<5>, ADC1>,
    pub in3: AdcPin<GpioPin<6>, ADC1>,
    pub in4: AdcPin<GpioPin<7>, ADC1>,
    pub in5: AdcPin<GpioPin<8>, ADC1>,
    pub in6: AdcPin<GpioPin<3>, ADC1>,
    pub in7: AdcPin<GpioPin<9>, ADC1>,
    pub in8: AdcPin<GpioPin<10>, ADC1>,
}

pub struct EspAdc {
    pins: AdcPins,
    calibration: AdcCalCurve<ADC1>,
    peripheral: Adc<'static, ADC1>,
}

pub struct Analog {
    pub adc: EspAdc,
}

impl Analog {
    pub fn new(adc: impl Peripheral<P = peripherals::ADC1> + 'static, pins: RawPins) -> Self {
        let mut config: AdcConfig<ADC1> = AdcConfig::<ADC1>::new();

        let adc_pins = AdcPins {
            in1: config.enable_pin_with_cal(pins.in1, Attenuation::_11dB),  //GPIO 4
            in2: config.enable_pin_with_cal(pins.in2, Attenuation::_11dB),  //GPIO 5
            in3: config.enable_pin_with_cal(pins.in3, Attenuation::_11dB),  //GPIO 6
            in4: config.enable_pin_with_cal(pins.in4, Attenuation::_11dB),  //GPIO 7
            in5: config.enable_pin_with_cal(pins.in5, Attenuation::_11dB),  //GPIO 8
            in6: config.enable_pin_with_cal(pins.in6, Attenuation::_11dB),  //GPIO 3
            in7: config.enable_pin_with_cal(pins.in7, Attenuation::_11dB),  //GPIO 9
            in8: config.enable_pin_with_cal(pins.in8, Attenuation::_11dB),  //GPIO 10
        };

        Analog {
            adc: EspAdc {
                pins: adc_pins,
                peripheral: Adc::new(adc, config),
                calibration: AdcCalCurve::<ADC1>::new_cal(Attenuation::_11dB),
            },
        }
    }
}

impl EspAdc {
    pub fn read(&mut self, input: InputRead) -> f32 {
        info!("Cal value: {:?}", self.calibration.adc_cal());
        let mut value: u16;

        match input {
            InputRead::IN1 => value = self.peripheral.read_blocking(&mut self.pins.in1),
            InputRead::IN2 => value = self.peripheral.read_blocking(&mut self.pins.in2),
            InputRead::IN3 => value = self.peripheral.read_blocking(&mut self.pins.in3),
            InputRead::IN4 => value = self.peripheral.read_blocking(&mut self.pins.in4),
            InputRead::IN5 => value = self.peripheral.read_blocking(&mut self.pins.in5),
            InputRead::IN6 => value = self.peripheral.read_blocking(&mut self.pins.in6),
            InputRead::IN7 => value = self.peripheral.read_blocking(&mut self.pins.in7),
            InputRead::IN8 => value = self.peripheral.read_blocking(&mut self.pins.in8),
        }

        for i in 0..4096 {
            info!(
                "Raw value: {:?}, Converted Value: {:?}",
                i,
                self.calibration.adc_val(i)
            );
        }

        value = self.calibration.adc_val(value);

        value as f32
    }
}