/*

 * // Copyright (c) Radzivon Bartoshyk 7/2025. All rights reserved.

 * //

 * // Redistribution and use in source and binary forms, with or without modification,

 * // are permitted provided that the following conditions are met:

 * //

 * // 1.  Redistributions of source code must retain the above copyright notice, this

 * // list of conditions and the following disclaimer.

 * //

 * // 2.  Redistributions in binary form must reproduce the above copyright notice,

 * // this list of conditions and the following disclaimer in the documentation

 * // and/or other materials provided with the distribution.

 * //

 * // 3.  Neither the name of the copyright holder nor the names of its

 * // contributors may be used to endorse or promote products derived from

 * // this software without specific prior written permission.

 * //

 * // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

 * // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 * // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 * // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

use crate::common::f_fmla;

use crate::double_double::DoubleDouble;

use std::ops::Neg;

#[derive(Clone, Copy, Debug)]

pub(crate) struct TripleDouble {

    pub(crate) hi: f64,

    pub(crate) mid: f64,

    pub(crate) lo: f64,

}

// impl TripleDouble {

//     #[inline]

//     pub(crate) fn mul_dd_add_f64(p0: TripleDouble, p1: DoubleDouble, p2: f64) -> TripleDouble {

//         let q0 = TripleDouble::quick_mul_dd(p0, p1);

//         TripleDouble::add_f64(p2, q0)

//     }

// }

impl TripleDouble {

    // #[inline]

    // pub(crate) fn mul_dd_add(p0: TripleDouble, p1: DoubleDouble, p2: TripleDouble) -> TripleDouble {

    //     let q0 = TripleDouble::quick_mul_dd(p0, p1);

    //     TripleDouble::add(q0, p2)

    // }

    // #[inline]

    // pub(crate) fn mul_dd_add_dd(

    //     p0: TripleDouble,

    //     p1: DoubleDouble,

    //     p2: DoubleDouble,

    // ) -> TripleDouble {

    //     let q0 = TripleDouble::quick_mul_dd(p0, p1);

    //     TripleDouble::add_dd(p2, q0)

    // }

}

impl TripleDouble {

    #[inline]

    pub(crate) fn f64_mul_dd_add(p0: f64, p1: DoubleDouble, p2: TripleDouble) -> TripleDouble {

        let q0 = TripleDouble::from_quick_mult_dd_f64(p1, p0);

        TripleDouble::add(q0, p2)

    }

    #[inline]

    pub(crate) fn f64_mul_add(p0: f64, p1: TripleDouble, p2: TripleDouble) -> TripleDouble {

        let q0 = TripleDouble::quick_mult_f64(p1, p0);

        TripleDouble::add(q0, p2)

    }

}

impl TripleDouble {

    #[inline]

    pub(crate) const fn from_bit_pair(p0: (u64, u64, u64)) -> TripleDouble {

        TripleDouble {

            hi: f64::from_bits(p0.2),

            mid: f64::from_bits(p0.1),

            lo: f64::from_bits(p0.0),

        }

    }

}

#[inline]

fn add12(a: f64, b: f64) -> DoubleDouble {

    DoubleDouble::from_full_exact_add(a, b)

}

#[inline]

fn mul12(a: f64, b: f64) -> DoubleDouble {

    DoubleDouble::from_exact_mult(a, b)

}

#[inline]

pub(crate) fn add22(a: DoubleDouble, b: DoubleDouble) -> DoubleDouble {

    let DoubleDouble { hi: v1, lo: v2 } = DoubleDouble::from_full_exact_add(a.hi, b.hi);

    let v3 = a.lo + b.lo;

    let v4 = v2 + v3;

    DoubleDouble::from_full_exact_add(v1, v4)

}

impl TripleDouble {

    // #[inline]

    // pub(crate) fn from_quick_mult_dd(a: DoubleDouble, b: DoubleDouble) -> TripleDouble {

    //     /*

    //     (rh , t1) ← Mul12 (ah , bh )

    //     (t2, t3) ← Mul12 (ah , bl )

    //     (t4, t5) ← Mul12 (al , bh )

    //     t6 ← al ⊗ bl

    //     (t7, t8) ← Add22 (t2, t3, t4, t5)

    //     (t9, t10) ← Add12 (t1, t6)

    //     (rm , rl ) ← Add22 (t7, t8, t9, t10)

    //      */

    //     let DoubleDouble { hi: rh, lo: t1 } = mul12(a.hi, b.hi);

    //     let r0 = mul12(a.hi, b.lo);

    //     let r1 = mul12(a.lo, b.hi);

    //     let t6 = a.lo * b.lo;

    //     let q0 = add22(r0, r1);

    //     let q1 = add12(t1, t6);

    //     let DoubleDouble { hi: rm, lo: rl } = add22(q0, q1);

    //     TripleDouble {

    //         hi: rh,

    //         mid: rm,

    //         lo: rl,

    //     }

    // }

    #[inline]

    pub(crate) fn from_quick_mult_dd_f64(a: DoubleDouble, b: f64) -> TripleDouble {

        let DoubleDouble { hi: rh, lo: t1 } = mul12(a.hi, b);

        let DoubleDouble { hi: t2, lo: t3 } = mul12(a.lo, b);

        let DoubleDouble { hi: t5, lo: t4 } = add12(t1, t2);

        let t6 = t3 + t4;

        let DoubleDouble { hi: rm, lo: rl } = add12(t5, t6);

        TripleDouble::new(rl, rm, rh)

    }

    #[inline]

    pub(crate) fn quick_mult_f64(a: TripleDouble, b: f64) -> TripleDouble {

        let DoubleDouble { hi: rh, lo: t2 } = mul12(a.hi, b);

        let DoubleDouble { hi: t3, lo: t4 } = mul12(a.mid, b);

        let DoubleDouble { hi: t9, lo: t7 } = add12(t2, t3);

        let t8 = f_fmla(a.lo, b, t4);

        let t10 = t7 + t8;

        let DoubleDouble { hi: rm, lo: rl } = add12(t9, t10);

        TripleDouble::new(rl, rm, rh)

    }

    #[inline]

    pub(crate) fn quick_mult(b: TripleDouble, a: TripleDouble) -> TripleDouble {

        /* Mul12((resh),&_t1,(ah),(bh));

        Mul12(&_t2,&_t3,(ah),(bm));

        Mul12(&_t4,&_t5,(am),(bh));

        Mul12(&_t6,&_t7,(am),(bm));

        _t8 = (ah) * (bl);

        _t9 = (al) * (bh);

        _t10 = (am) * (bl);

        _t11 = (al) * (bm);

        _t12 = _t8 + _t9;

        _t13 = _t10 + _t11;

        Add12Cond(_t14,_t15,_t1,_t6);

        _t16 = _t7 + _t15;

        _t17 = _t12 + _t13;

        _t18 = _t16 + _t17;

        Add12Cond(_t19,_t20,_t14,_t18);

        Add22Cond(&_t21,&_t22,_t2,_t3,_t4,_t5);

        Add22Cond((resm),(resl),_t21,_t22,_t19,_t20);   */

        let DoubleDouble { hi: rh, lo: t1 } = DoubleDouble::from_exact_mult(a.hi, b.hi);

        let DoubleDouble { hi: t2, lo: t3 } = DoubleDouble::from_exact_mult(a.hi, b.mid);

        let DoubleDouble { hi: t4, lo: t5 } = DoubleDouble::from_exact_mult(a.mid, b.hi);

        let DoubleDouble { hi: t6, lo: t7 } = DoubleDouble::from_exact_mult(a.mid, b.mid);

        let t12 = f_fmla(a.hi, b.lo, a.lo * b.hi);

        let t13 = f_fmla(a.mid, b.lo, a.lo * b.mid);

        let DoubleDouble { hi: t14, lo: t15 } = add12(t1, t6);

        let t16 = t7 + t15;

        let t17 = t12 + t13;

        let t18 = t16 + t17;

        let DoubleDouble { hi: t19, lo: t20 } = add12(t14, t18);

        let DoubleDouble { hi: t21, lo: t22 } =

            add22(DoubleDouble::new(t3, t2), DoubleDouble::new(t4, t5));

        let DoubleDouble { hi: rm, lo: rl } =

            add22(DoubleDouble::new(t22, t21), DoubleDouble::new(t20, t19));

        TripleDouble::new(rl, rm, rh)

    }

    #[inline]

    pub(crate) fn quick_mult_dd(b: TripleDouble, a: DoubleDouble) -> TripleDouble {

        /*

        (rh , t1) ← Mul12 (ah , bh )

        (t2, t3) ← Mul12 (ah , bm )

        (t4, t5) ← Mul12 (ah , bl )

        (t6, t7) ← Mul12 (al , bh )

        (t8, t9) ← Mul12 (al , bm )

        t10 ← al ⊗ bl

        (t11, t12) ← Add22 (t2, t3, t4, t5)

        (t13, t14) ← Add22 (t6, t7, t8, t9)

        (t15, t16) ← Add22 (t11, t12, t13, t14)

        (t17, t18) ← Add12 (t1, t10)

        (rm , rl ) ← Add22 (t17, t18, t15, t16)

        */

        let DoubleDouble { hi: rh, lo: t1 } = mul12(a.hi, b.hi);

        let DoubleDouble { hi: t2, lo: t3 } = mul12(a.hi, b.mid);

        let DoubleDouble { hi: t4, lo: t5 } = mul12(a.hi, b.lo);

        let DoubleDouble { hi: t6, lo: t7 } = mul12(a.lo, b.hi);

        let DoubleDouble { hi: t8, lo: t9 } = mul12(a.lo, b.mid);

        let t10 = a.lo * b.lo;

        let z0 = add22(DoubleDouble::new(t3, t2), DoubleDouble::new(t4, t5));

        let z1 = add22(DoubleDouble::new(t6, t7), DoubleDouble::new(t8, t9));

        let q0 = add22(z0, z1);

        let q1 = add12(t1, t10);

        let DoubleDouble { hi: rm, lo: rl } = add22(q1, q0);

        TripleDouble {

            hi: rh,

            mid: rm,

            lo: rl,

        }

    }

    pub(crate) fn add(a: TripleDouble, b: TripleDouble) -> TripleDouble {

        /*

        (rh , t1) ← Add12 (ah , bh )

        (t2, t3) ← Add12 (am , bm )

        (t7, t4) ← Add12 (t1, t2)

        t6 ← al ⊕ bl

        t5 ← t3 ⊕ t4

        t8 ← t5 ⊕ t6

        (rm , rl ) ← Add12 (t7, t8)

                 */

        let DoubleDouble { hi: rh, lo: t1 } = add12(a.hi, b.hi);

        let DoubleDouble { hi: t2, lo: t3 } = add12(a.mid, b.mid);

        let t6 = a.lo + b.lo;

        let DoubleDouble { hi: t7, lo: t4 } = add12(t1, t2);

        let t5 = t3 + t4;

        let t8 = t5 + t6;

        let DoubleDouble { hi: rm, lo: rl } = add12(t7, t8);

        TripleDouble {

            hi: rh,

            mid: rm,

            lo: rl,

        }

    }

    // #[inline]

    // pub(crate) fn add_dd(a: DoubleDouble, b: TripleDouble) -> TripleDouble {

    //     /*

    //     (rh , t1) ← Add12 (ah , bh )

    //     (t2, t3) ← Add12 (al , bm )

    //     (t4, t5) ← Add12 (t1, t2)

    //     t6 ← t3 ⊕ bl

    //     t7 ← t6 ⊕ t5

    //     (rm , rl ) ← Add12 (t4, t7)

    //      */

    //     let DoubleDouble { hi: rh, lo: t1 } = add12(a.hi, b.hi);

    //     let DoubleDouble { hi: t2, lo: t3 } = add12(a.hi, b.mid);

    //     let DoubleDouble { hi: t4, lo: t5 } = add12(t1, t2);

    //     let t6 = t3 + b.lo;

    //     let t7 = t6 + t5;

    //     let DoubleDouble { hi: rm, lo: rl } = add12(t4, t7);

    //     TripleDouble {

    //         hi: rh,

    //         mid: rm,

    //         lo: rl,

    //     }

    // }

    #[inline]

    pub(crate) fn add_f64(a: f64, b: TripleDouble) -> TripleDouble {

        let DoubleDouble { hi: rh, lo: t1 } = add12(a, b.hi);

        let DoubleDouble { hi: t2, lo: t3 } = add12(t1, b.mid);

        let t4 = t3 + b.lo;

        let DoubleDouble { hi: rm, lo: rl } = add12(t2, t4);

        TripleDouble::new(rl, rm, rh)

    }

    // #[inline]

    // pub(crate) fn to_dd(self) -> DoubleDouble {

    //     let DoubleDouble { hi: t1, lo: t2 } = add12(self.hi, self.mid);

    //     let t3 = t2 + self.lo;

    //     DoubleDouble::new(t3, t1)

    // }

    #[inline]

    pub(crate) const fn new(lo: f64, mid: f64, hi: f64) -> Self {

        Self { hi, mid, lo }

    }

    #[inline]

    pub(crate) fn to_f64(self) -> f64 {

        let DoubleDouble { hi: t1, lo: t2 } = add12(self.hi, self.mid);

        let t3 = t2 + self.lo;

        t1 + t3

    }

    #[inline]

    pub(crate) fn from_full_exact_add(a: f64, b: f64) -> Self {

        let DoubleDouble { hi: rh, lo: t1 } = add12(a, b);

        TripleDouble::new(0., t1, rh).renormalize()

    }

    #[inline]

    pub(crate) fn renormalize(self) -> Self {

        /*

           double _t1h, _t1l, _t2l;

        Add12(_t1h, _t1l, (am), (al));

        Add12((*(resh)), _t2l, (ah), (_t1h));

        Add12((*(resm)), (*(resl)), _t2l, _t1l);

         */

        let DoubleDouble { hi: t1h, lo: t1l } = DoubleDouble::from_exact_add(self.mid, self.lo);

        let DoubleDouble { hi: rh, lo: t2l } = DoubleDouble::from_exact_add(self.hi, t1h);

        let zml = DoubleDouble::from_exact_add(t2l, t1l);

        TripleDouble::new(zml.lo, zml.hi, rh)

    }

    #[inline]

    pub(crate) fn recip(self) -> Self {

        /*

              _rec_r1 = 1.0 / (dh);

        Mul12(&_rec_t1,&_rec_t2,_rec_r1,(dh));

        _rec_t3 = _rec_t1 - 1.0;

        Add12Cond(_rec_t4,_rec_t5,_rec_t3,_rec_t2);

        Mul12(&_rec_t6,&_rec_t7,_rec_r1,(dm));

        Add12(_rec_t8,_rec_t9,-1.0,_rec_t6);

        _rec_t10 = _rec_t9 + _rec_t7;

        Add12(_rec_t11,_rec_t12,_rec_t8,_rec_t10);

        _rec_r1 = -_rec_r1;

        Add22Cond(&_rec_t13,&_rec_t14,_rec_t4,_rec_t5,_rec_t11,_rec_t12);

        Mul122(&_rec_r2h,&_rec_r2l,_rec_r1,_rec_t13,_rec_t14);

        Mul233(&_rec_t15,&_rec_t16,&_rec_t17,_rec_r2h,_rec_r2l,(dh),(dm),(dl));

        Renormalize3(&_rec_t18,&_rec_t19,&_rec_t20,_rec_t15,_rec_t16,_rec_t17);

        _rec_t18 = -1.0;

        Mul233(&_rec_t21,&_rec_t22,&_rec_t23,_rec_r2h,_rec_r2l,_rec_t18,_rec_t19,_rec_t20);

        _rec_t21 = -_rec_t21; _rec_t22 = -_rec_t22; _rec_t23 = -_rec_t23;

        Renormalize3((resh),(resm),(resl),_rec_t21,_rec_t22,_rec_t23);

             */

        let mut r1 = 1. / self.hi;

        let DoubleDouble {

            hi: rec_t1,

            lo: rec_t2,

        } = DoubleDouble::from_exact_mult(r1, self.hi);

        let rec_t3 = rec_t1 - 1.0;

        let DoubleDouble {

            hi: rec_t4,

            lo: rec_t5,

        } = add12(rec_t3, rec_t2);

        let DoubleDouble {

            hi: rec_t6,

            lo: rec_t7,

        } = mul12(r1, self.mid);

        let DoubleDouble {

            hi: rec_t8,

            lo: rec_t9,

        } = add12(-1.0, rec_t6);

        let rec_t10 = rec_t9 + rec_t7;

        r1 = -r1;

        let DoubleDouble {

            hi: rec_t11,

            lo: rec_t12,

        } = add12(rec_t8, rec_t10);

        let z0 = add22(

            DoubleDouble::new(rec_t5, rec_t4),

            DoubleDouble::new(rec_t12, rec_t11),

        );

        let r2hl = DoubleDouble::quick_mult_f64(z0, r1);

        let rec15_16_17 = TripleDouble::quick_mult_dd(self, r2hl);

        let rec18_19_20 = rec15_16_17.renormalize();

        let rec_t18 = -1.0;

        let rec_21_22_23 = -TripleDouble::quick_mult_dd(

            TripleDouble::new(rec18_19_20.lo, rec18_19_20.mid, rec_t18),

            r2hl,

        );

        rec_21_22_23.renormalize()

    }

}

impl Neg for TripleDouble {

    type Output = Self;

    #[inline]

    fn neg(self) -> Self::Output {

        TripleDouble::new(-self.lo, -self.mid, -self.hi)

    }

}