extern crate byteorder;

pub mod basic;
pub mod record;
pub mod records;
pub mod elements;
pub mod library;

use crate::library::read_library;

use byteorder::{ByteOrder, BigEndian};
use std::mem::size_of;
use std::ffi::{CStr, OsStr, c_char};
use std::os::unix::ffi::OsStrExt;
use std::str;
use std::fs;
use std::path::Path;

use arrow::ffi::{to_ffi, FFI_ArrowArray, FFI_ArrowSchema};
use arrow::array::Array;

#[no_mangle]
pub unsafe extern "C" fn read_path(
        cpath: *const c_char,
        arr: *mut FFI_ArrowArray,
        schema: *mut FFI_ArrowSchema,
        ) {
    let cstr = unsafe { CStr::from_ptr(cpath) };
    let path: &Path;
    if cfg!(unix) {
        let osstr = OsStr::from_bytes(cstr.to_bytes());
        path = osstr.as_ref();
    } else if cfg!(windows) {
        let ustr = str::from_utf8(cstr.to_bytes()).expect("Non-UTF8 paths are not supported");
        path = ustr.as_ref();
    } else {
        panic!("Unsupported OS");
    }

    println!("{cstr:?}");
    println!("{path:?}");
    let input = fs::read(path).expect("File read failed");
    let (_input, struct_arr) = read_library(&input).expect("Read failed");
    (*arr, *schema) = to_ffi(&struct_arr.to_data()).unwrap();
}


macro_rules! impl_i16be {
    ( $tt:ty, $arr:ident, $size:ident ) => {
        {
            let sl = unsafe { std::slice::from_raw_parts_mut($arr, $size) };
            for xx in sl.iter_mut() {
                if *xx < i16::MIN as $tt { return *xx }
                if *xx > i16::MAX as $tt { return *xx }

                let mut buf = [0; size_of::<$tt>()];
                BigEndian::write_i16(&mut buf, *xx as i16);
                *xx = <$tt>::from_le_bytes(buf);
            }
            0 as $tt
        }
    }
}


macro_rules! impl_i32be {
    ( $tt:ty, $arr:ident, $size:ident ) => {
        {
            let sl = unsafe { std::slice::from_raw_parts_mut($arr, $size) };
            for xx in sl.iter_mut() {
                if *xx < i32::MIN as $tt { return *xx }
                if *xx > i32::MAX as $tt { return *xx }

                let mut buf = [0; size_of::<$tt>()];
                BigEndian::write_i32(&mut buf, *xx as i32);
                *xx = <$tt>::from_le_bytes(buf);
            }
            0 as $tt
        }
    }
}


#[no_mangle]
pub unsafe extern "C" fn f64_to_i16(arr: *mut f64, size: usize) -> f64 { impl_i16be!(f64, arr, size) }
#[no_mangle]
pub unsafe extern "C" fn f64_to_i32(arr: *mut f64, size: usize) -> f64 { impl_i32be!(f64, arr, size) }

#[no_mangle]
pub unsafe extern "C" fn f32_to_i16(arr: *mut f32, size: usize) -> f32 { impl_i16be!(f32, arr, size) }
#[no_mangle]
pub unsafe extern "C" fn f32_to_i32(arr: *mut f32, size: usize) -> f32 { impl_i32be!(f32, arr, size) }

#[no_mangle]
pub unsafe extern "C" fn u64_to_i16(arr: *mut u64, size: usize) -> u64 { impl_i16be!(u64, arr, size) }
#[no_mangle]
pub unsafe extern "C" fn u64_to_i32(arr: *mut u64, size: usize) -> u64 { impl_i32be!(u64, arr, size) }

#[no_mangle]
pub unsafe extern "C" fn i64_to_i16(arr: *mut i64, size: usize) -> i64 { impl_i16be!(i64, arr, size) }
#[no_mangle]
pub unsafe extern "C" fn i64_to_i32(arr: *mut i64, size: usize) -> i64 { impl_i32be!(i64, arr, size) }

#[no_mangle]
pub unsafe extern "C" fn u32_to_i16(arr: *mut u32, size: usize) -> u32 { impl_i16be!(u32, arr, size) }
#[no_mangle]
pub unsafe extern "C" fn u32_to_i32(arr: *mut u32, size: usize) -> u32 { impl_i32be!(u32, arr, size) }

#[no_mangle]
pub unsafe extern "C" fn i32_to_i16(arr: *mut i32, size: usize) -> i32 { impl_i16be!(i32, arr, size) }
#[no_mangle]
pub unsafe extern "C" fn i32_to_i32(arr: *mut i32, size: usize) -> i32 { impl_i32be!(i32, arr, size) }


#[no_mangle]
pub unsafe extern "C" fn u16_to_i16(arr: *mut u16, size: usize) -> u16 { impl_i16be!(u16, arr, size) }

#[no_mangle]
pub unsafe extern "C" fn i16_to_i16(arr: *mut i16, size: usize) -> i16 { impl_i16be!(i16, arr, size) }

