module os

// write_le writes an unsigned number value to the file.
// It assumes that the value should be stored in a *little endian order*.
// If the machine is a big endian one, it will first convert the big endian value to a little endian one.
// It is safe to use as a cross platform way to write data, for which you have to use a predefined order (defined in a file format spec).
pub fn (mut f File) write_le[T](data T) ! {
    mut serialized := data
    $if big_endian {
        serialized = swap_bytes(serialized)
    }
    C.errno = 0 // needed for tcc
    check_fwrite(C.fwrite(voidptr(&serialized), sizeof(T), 1, f.cfile))!
}

// write_be writes an unsigned number value to the file.
// It assumes that the value should be stored in a *big endian order*.
// If the machine is a little endian one, it will first convert the little endian value to a big endian one.
// It is safe to use as a cross platform way to write data, for which you have to use a predefined order (defined in a file format spec).
pub fn (mut f File) write_be[T](data T) ! {
    mut serialized := data
    $if little_endian {
        serialized = swap_bytes(serialized)
    }
    C.errno = 0 // needed for tcc
    check_fwrite(C.fwrite(voidptr(&serialized), sizeof(T), 1, f.cfile))!
}

// read_le reads an unsigned number value from the file.
// It assumes that the value was stored in a *little endian order*.
// If the machine is a big endian one, it will convert the value to a big endian one.
// It is intended to use as a cross platform way to read data, for which the order is known (from the file format spec).
pub fn (mut f File) read_le[T]() !T {
    mut serialized := T(0)
    C.errno = 0 // needed for tcc
    check_fread(C.fread(voidptr(&serialized), sizeof(T), 1, f.cfile))!
    $if big_endian {
        return swap_bytes(serialized)
    }
    return serialized
}

// read_be reads an unsigned number value from the file.
// It assumes that the value was stored in a *big endian order*.
// If the machine is a little endian one, it will convert the value to a little endian one.
// It is intended to use as a cross platform way to read data, for which the order is known (from the file format spec).
pub fn (mut f File) read_be[T]() !T {
    mut serialized := T(0)
    C.errno = 0 // needed for tcc
    check_fread(C.fread(voidptr(&serialized), sizeof(T), 1, f.cfile))!
    $if little_endian {
        return swap_bytes(serialized)
    }
    return serialized
}

// write_u8 writes a single byte value to the file `f`.
// Note: if possible, use some of the other APIs, that write larger chunks of data, before using write_u8/1.
pub fn (mut f File) write_u8(b u8) ! {
    C.errno = 0 // needed for tcc
    check_fwrite(C.fwrite(voidptr(&b), 1, 1, f.cfile))!
}

// read_u8 reads a single byte value from the file `f`.
// Note: if possible, use some of the other APIs, that read larger chunks of data, before using read_u8/1.
pub fn (mut f File) read_u8() !u8 {
    mut res := u8(0)
    C.errno = 0 // needed for tcc
    check_fread(C.fread(voidptr(&res), 1, 1, f.cfile))!
    return res
}

// private helpers

@[inline]
fn swap_bytes_u16(x u16) u16 {
    // vfmt off
    return ((x >> 8) & 0x00FF) |
           ((x << 8) & 0xFF00)
    // vfmt on
}

@[inline]
fn swap_bytes_u32(x u32) u32 {
    // vfmt off
    return ((x >> 24) & 0x0000_00FF) |
           ((x >> 8)  & 0x0000_FF00) |
           ((x << 8)  & 0x00FF_0000) |
           ((x << 24) & 0xFF00_0000)
    // vfmt on
}

@[inline]
fn swap_bytes_u64(x u64) u64 {
    // vfmt off
    return ((x >> 56) & 0x00000000_000000FF) |
           ((x >> 40) & 0x00000000_0000FF00) |
           ((x >> 24) & 0x00000000_00FF0000) |
           ((x >> 8)  & 0x00000000_FF000000) |
           ((x << 8)  & 0x000000FF_00000000) |
           ((x << 24) & 0x0000FF00_00000000) |
           ((x << 40) & 0x00FF0000_00000000) |
           ((x << 56) & 0xFF000000_00000000)
    // vfmt on
}

fn swap_bytes[T](input T) T {
    $if T is u8 {
        return input
    } $else $if T is i8 {
        return input
    } $else $if T is u16 {
        return swap_bytes_u16(input)
    } $else $if T is u32 {
        return swap_bytes_u32(input)
    } $else $if T is u64 {
        return swap_bytes_u64(input)
    } $else $if T is i16 {
        return i16(swap_bytes_u16(u16(input)))
    } $else $if T is i32 {
        return i32(swap_bytes_u32(u32(input)))
    } $else $if T is int {
        return i32(swap_bytes_u32(u32(input)))
    } $else $if T is i64 {
        return i64(swap_bytes_u64(u64(input)))
    } $else {
        panic('type is not supported: ' + typeof[T]().str())
    }
}

fn check_cf(x usize, label string) ! {
    if C.errno != 0 {
        return error(posix_get_error_msg(C.errno))
    }
    if x == 0 {
        return error(label)
    }
}

fn check_fwrite(x usize) ! {
    check_cf(x, 'fwrite')!
}

fn check_fread(x usize) ! {
    check_cf(x, 'fread')!
}