{-# LANGUAGE ForeignFunctionInterface #-}

import Foreign
import Foreign.C.Types

foreign import ccall unsafe "math.h sin"
  c_sin :: CDouble -> CDouble

foreign import ccall unsafe "stdlib.h rand"
  c_rand :: IO CUInt

int thing_get_version(thing_t *thing);

char* thing_get_name(thing_t *thing);

int thing_new(char *name, thing_t **p);

foreign import ccall unsafe "thing.h thing_get_version"
  c_thing_get_version :: Ptr Thing -> CInt

foreign import ccall unsafe "thing.h thing_get_name"
  c_thing_get_name :: Ptr Thing -> Ptr CChar

foreign import ccall unsafe "thing.h thing_new"
  c_thing_new :: Ptr CChar -> Ptr (Ptr Thing) -> IO CInt

module Foreign.Storable where

class Storable a where
  {-# MINIMAL sizeOf
            , alignment
            , (peek | peekElemOff | peekByteOff)
            , (poke | pokeElemOff | pokeByteOff) 
            #-}

  sizeOf :: a -> Int
  -- ^ computes the storage requirements (in bytes) of the argument
  -- the argument is not used so you can pass `undefined`

  alignment :: a -> Int
  -- ^ computes the alignment constraint of the argument

  peek :: Ptr a -> IO a
  -- ^ read a value from a memory location

  poke :: Ptr a -> a -> IO ()
  -- ^ write a value to a memory location

  -- default implementations
  peekElemOff :: Ptr a -> Int -> IO a
  -- ^ peekElemOff p i reads a value from a memory location p + i * sizeOf a

  pokeElemOff :: Ptr a -> Int -> a -> IO ()
  -- ^ pokeElemOff p i writes a value to a memory location p + i * sizeOf a

  peekByteOff :: Ptr b -> Int -> IO a
  -- ^ peekByteOff p i reads a value from a memory location p + i

  pokeByteOff :: Ptr b -> Int -> a -> IO ()
  -- ^ pokeByteOff p i writes a value to a memory location p + i

type FinalizerPtr a = FunPtr (Ptr a -> IO ())
-- ^ a finalizer is a pointer to a foreign function that will be called when the ForeignPtr is no longer referenced

newForeignPtr :: FinalizerPtr a -> Ptr a -> IO (ForeignPtr a)
-- ^ create a ForeignPtr with a finalizer

withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b
-- ^ perform an action on the pointer inside a ForeignPtr

type CString = Ptr CChar
-- ^ this is the definition of CString in Foreign.C.String
-- so you can write CString instead of Ptr CChar

peekCString :: CString -> IO String
-- ^ convert a CString to a Haskell String

withCString :: String -> (CString -> IO a) -> IO a
-- ^ convert a Haskell String to a CString

typedef enum {
  Alpha_alpha, Beta_beta, Gamma_gamma, Delta_delta
} some_enum;

{#enum some_enum as SomeEnum {underscoreToCase} deriving (Eq, Show) #}

-- this will generate the following code

data SomeEnum = AlphaAlpha | BetaBeta | GammaGamma | DeltaDelta
  deriving (Enum, Eq, Show)

typedef struct {
  int x;
  int y;
} point_t;

{#pointer *point_t as PointT #}

-- this will generate the following code

mkdir FFILearn
cd FFILearn
cabal init -n

mkdir c-src
mkdir include

// c-src/myclib.h
#ifndef MYCLIB_H
#define MYCLIB_H

// Function to add two integers, testing FFI
int mylib_add(int a, int b);

// Function to print a string, testing FFI
void mylib_print(const char* str);

// Function that returns a pointer to a string, testing FFI
const char* mylib_get_string();

#endif // MYCLIB_H

//include/myclib.c
#include "myclib.h"
#include <stdio.h>

// Function to add two integers, testing FFI
int mylib_add(int a, int b) {
    return a + b;
}

// Function to print a string, testing FFI
void mylib_print(const char* str) {
    printf("%s\n", str);
}

// Function that returns a pointer to a string, testing FFI
const char* mylib_get_string() {
    return "String from mylib!";
}

-- app/MyLib.hs
module MyLib where

import Foreign.C.Types
import Foreign.C.String

foreign import ccall "myclib.h mylib_add"
  c_mylib_add :: CInt -> CInt -> CInt

foreign import ccall "myclib.h mylib_print"
  c_mylib_print :: CString -> IO ()

foreign import ccall "myclib.h mylib_get_string"
  c_mylib_get_string :: IO CString

mylib_add :: Int -> Int -> Int
mylib_add a b = fromIntegral $ c_mylib_add (fromIntegral a) (fromIntegral b)

mylib_print :: String -> IO ()
mylib_print s = withCString s c_mylib_print

mylib_get_string :: IO String
mylib_get_string = do
  cs <- c_mylib_get_string
  peekCString cs

-- app/Main.hs
module Main where

import MyLib

main :: IO ()
main = do
  mylib_print $ "add 1 2 = " ++ show (mylib_add 1 2)
  mylib_print $ "add 3 4 = " ++ show (mylib_add 3 4)
  mylib_print "Hello from Haskell!"
  s <- mylib_get_string
  mylib_print $ "mylib_get_string = " ++ s

cabal build
cabal run

{-# LANGUAGE QuasiQuotes, TemplateHaskell #-}
module MyLib where

import qualified Language.C.Inline as C
import qualified Language.C.Inline.Unsafe as CU
import Foreign.C.String (newCString)
import System.IO.Unsafe (unsafeDupablePerformIO)

C.include "<stdio.h>"

myAdd :: Int -> Int -> Int
myAdd a b =
  let a' = fromIntegral a
      b' = fromIntegral b
  in fromIntegral [CU.pure| long { $(long a') + $(long b') } |]

myFib :: Int -> Int
myFib n =
  let n' = fromIntegral n
  in fromIntegral $ unsafeDupablePerformIO 
      -- unsafeDupablePerformIO avoids the overhead of unsafePerformIO
      [CU.block|
      long {
        long a = 0, b = 1, c;
        for (int i = 0; i < $(int n'); i++) {
          c = a + b;
          a = b;
          b = c;
        }
        return a;
      } |]

myPrint :: String -> IO ()
myPrint str = do
  cstr <- newCString str
  [CU.exp| void { printf("%s\n", $(const char *cstr)) } |]

module Main where

import MyLib

main :: IO ()
main = do
  myPrint $ "1 + 2 = " ++ show (myAdd 1 2)
  myPrint $ "fib 50 = " ++ show (myFib 50)
  myPrint "Hello, world! (from C using printf)"