{-# LANGUAGE Haskell2010, FlexibleContexts #-}
-- {-# OPTIONS -Wall -fno-warn-name-shadowing #-}

-- | Functions for generating glue code between Haskell and Java.
module CodeGen.JavaBindings where

import CodeGen.Class
import CodeGen.Typomatic
import Types
import Utils

import qualified Haskell.X as X
import Haskell.X.Unsafe
import Haskell.X.Ops

import Control.Applicative
import Control.Monad
import Control.Monad.IO.Class

import Data.Function
import qualified Data.List as L
import qualified Data.Char as C


imports :: Monad m => CodeGenerator m
-- ^ Imports of all auto generated java code files.
imports = do
    return ((\_ -> let { __ = 
{-# LINE 28 "CodeGen/JavaBindings.hss" #-}
concat ["import qualified Foreign.Java as JNI\nimport Foreign.Java ((-->))\nimport qualified Prelude as P\nimport Prelude ((.), ($), (>>=), (>>), return)\nimport qualified Foreign.Java.Bindings as JNIS\nimport Data.Functor ((<$>))\n"]
{-# LINE 35 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)


javaPackageModule :: Monad m => String -> CodeGenerator m
-- ^ java.lang -> Java.Lang (package hierarchy)
javaPackageModule packageName = do

    commonImports <- imports
    deps <- getPackageModuleDeps packageName

    moduleName <- getModNameForPackage packageName
    moduleComment <- return ((\_ -> let { __ = 
{-# LINE 46 "CodeGen/JavaBindings.hss" #-}
concat ["The @", (packageName), "@ package."]
{-# LINE 46 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    moduleImports <- return deps
        >>= return . concatMap (\name -> "import " ++ name ++ "__\n")
    moduleExports <- return deps
        >>= return . concat . L.intersperse ",\n" . map (\x -> "module " ++ x ++ "__")

    return ((\_ -> let { __ = 
{-# LINE 52 "CodeGen/JavaBindings.hss" #-}
concat ["{-# LANGUAGE Haskell2010 #-}\n-- | ", (moduleComment), "\nmodule ", (moduleName), " (\n", (moduleExports), ") where\n", (commonImports), "\n", (moduleImports), "\n"]
{-# LINE 60 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)


readArg :: String -> JavaType -> String
readArg name jtype = case jtype of
    JBoolean -> ((\_ -> let { __ = 
{-# LINE 65 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- JNIS.toBoolean ", (name), "\n"]
{-# LINE 65 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    JChar    -> ((\_ -> let { __ = 
{-# LINE 66 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- JNIS.toChar ", (name), "\n"]
{-# LINE 66 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    JByte    -> ((\_ -> let { __ = 
{-# LINE 67 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- JNIS.toByte ", (name), "\n"]
{-# LINE 67 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    JShort   -> ((\_ -> let { __ = 
{-# LINE 68 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- JNIS.toShort ", (name), "\n"]
{-# LINE 68 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    JInt     -> ((\_ -> let { __ = 
{-# LINE 69 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- JNIS.toInt ", (name), "\n"]
{-# LINE 69 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    JLong    -> ((\_ -> let { __ = 
{-# LINE 70 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- JNIS.toLong ", (name), "\n"]
{-# LINE 70 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    JFloat   -> ((\_ -> let { __ = 
{-# LINE 71 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- JNIS.toFloat ", (name), "\n"]
{-# LINE 71 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    JDouble  -> ((\_ -> let { __ = 
{-# LINE 72 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- JNIS.toDouble ", (name), "\n"]
{-# LINE 72 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    JObj _   -> ((\_ -> let { __ = 
{-# LINE 73 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- P.Just <$> JNI.asObject ", (name), "\n"]
{-# LINE 73 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
    JArr _   -> ((\_ -> let { __ = 
{-# LINE 74 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), "' <- JNIS.asMaybeArrayObject ", (name), "\n"]
{-# LINE 74 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

convertResult :: Maybe JavaType -> String
convertResult rtype = case rtype of
    Nothing -> "JNIS.toVoidResult"
    Just t -> case t of
        JBoolean -> "JNIS.toBooleanResult"
        JChar    -> "JNIS.toCharResult"
        JByte    -> "JNIS.toByteResult"
        JShort   -> "JNIS.toShortResult"
        JInt     -> "JNIS.toIntResult"
        JLong    -> "JNIS.toLongResult"
        JFloat   -> "JNIS.toFloatResult"
        JDouble  -> "JNIS.toDoubleResult"
        JObj n   -> "JNIS.toObjectResult"
        JArr c   -> "(\\x -> let (P.Right (P.Just y)) = x in return y)"


javaClassModule :: (Functor m, Monad m) => String -> CodeGenerator m
-- ^ java.lang.Thread -> Java.Lang.Thread (implementation file)
javaClassModule className = do

    clazz <- getClassInfoFor className
    commonImports <- imports
    moduleName <- getModNameForClass className
    let baseName = takeClassName moduleName
        isIface  = classIface clazz

    moduleImports <- getClassModuleDeps clazz
        >>= return . concatMap (\name -> "import qualified " ++ name ++ "__\n")

    let mkConstructorNames :: [JavaConstructor] -> [String]
        mkConstructorNames = zipWith (flip (++)) (iterate (++"'") "") . map (const $ "new'" ++ baseName)

        mkMethodNames :: [JavaMethod] -> [String]
        mkMethodNames = concatMap (zipWith (flip (++)) (iterate (++"'") ""))
                        . L.group . map sanitize . map methodName
          where
            sanitize name
              | C.isUpper (head name) = '_' : name
              | name `elem` haskellKeywords = name ++ "'"
              | otherwise = name

        mkFields :: [JavaField] -> [(JavaField, (String, Maybe String))]
        mkFields = map mkField . L.nubBy ((==) `on` fieldName)
          where
            mkField f = (f, ("get'" ++ name, (if fieldFinal f then Nothing else Just ("set'" ++ name))))
              where name = fieldName f

        methods_ = L.sortBy (compare `on` methodName) (classMethods clazz)
        constrs_ = L.sortBy compareConstructors (classConstructors clazz)

        compareConstructors a b = length (constructorParams a) `compare` length (constructorParams b)

    constrNames <- constrs_ =>> mkConstructorNames
    methodNames <- methods_ =>> mkMethodNames

    constrs <- constrNames =>> zip constrs_
    methods <- methodNames =>> zip methods_
    fields  <- (classFields clazz) =>> mkFields

    let (constrNames, fieldNames, methodNames)
          = (map snd constrs,
             concatMap (\(_, (g, s)) -> g : maybe [] (:[]) s) fields,
             map snd methods)
        functions = concat [constrNames, fieldNames, methodNames]
        ifaceConstructor = ((\_ -> let { __ = 
{-# LINE 140 "CodeGen/JavaBindings.hss" #-}
concat ["new'", (baseName), ""]
{-# LINE 140 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        constructors
            | classIface clazz = ((\_ -> let { __ = 
{-# LINE 142 "CodeGen/JavaBindings.hss" #-}
concat ["-- * Constructors\n", (ifaceConstructor), ",\n\n"]
{-# LINE 145 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
            | otherwise = ((\_ -> let { __ = 
{-# LINE 146 "CodeGen/JavaBindings.hss" #-}
concat ["-- * Constructors\n", (if null constrs then '-':"- | No Constructors!" else concatMap (++ ",\n") constrNames), "\n\n"]
{-# LINE 149 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

    moduleComment <- return ""
    moduleExports <- return ((\_ -> let { __ = 
{-# LINE 152 "CodeGen/JavaBindings.hss" #-}
concat ["", (constructors), "\n-- * Fields\n", (if null fields then '-':"- | No Fields!" else concatMap (++ ",\n") fieldNames), "\n\n-- * Methods\n", (if null methods then '-':"- | No Methods!" else concat $ L.intersperse ",\n" methodNames), "\n"]
{-# LINE 159 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

    infoFunc <- getClassInfoFunc
    modFunc  <- getClassModFunc

    constrDeclarations <- case classIface clazz of
        True -> return ((\_ -> let { __ = 
{-# LINE 165 "CodeGen/JavaBindings.hss" #-}
concat ["", (ifaceConstructor), " :: a\n", (ifaceConstructor), " = P.undefined\n\n"]
{-# LINE 168 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        False -> fmap concat $ forM constrs $ \(constr, name) -> do
            let argsInfo = runTypomatic infoFunc (constructorType clazz constr modFunc)
                args = fArgNames argsInfo

                readArgs = concatMap (("    " ++) . uncurry readArg)
                                     (zip args (map fst $ constructorParams constr))

                preamble = ((\_ -> let { __ = 
{-# LINE 176 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), " :: ", (fSignature argsInfo), "\n", (name), "", (concatMap (' ':) args), " = do\n    (P.Just clazz) <- JNI.getClass \"", (className), "\"\n"]
{-# LINE 180 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

            case constructorParams constr of
                [] -> return ((\_ -> let { __ = 
{-# LINE 183 "CodeGen/JavaBindings.hss" #-}
concat ["", (preamble), "\n    JNI.newObjectE clazz >>= JNIS.toObjectResult\n\n"]
{-# LINE 186 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
                _ -> return ((\_ -> let { __ = 
{-# LINE 187 "CodeGen/JavaBindings.hss" #-}
concat ["", (preamble), "\n    (P.Just constr) <- JNI.getConstructor clazz $ ", (fJniSignature argsInfo), "\n", (readArgs), "    result <- JNI.newObjectFromE constr ", (concatMap (++ "' ") args), "\n    JNIS.toObjectResult result\n\n"]
{-# LINE 193 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)


    methodDeclarations <- fmap concat $ forM methods $ \(method, name) -> do

        let isStatic = methodStatic method
            getMethod = if isStatic then "getStaticMethod" else "getMethod"
            callMethod = if isStatic then "callStaticMethodE" else "callMethodE"

            argsInfo = runTypomatic infoFunc (methodType clazz method modFunc)
            args = fArgNames argsInfo
            argsNotThis = (if isStatic then id else tail) args

            haddock = ((\_ -> let { __ = 
{-# LINE 206 "CodeGen/JavaBindings.hss" #-}
concat ["@", (if isStatic then "static " else "virtual "), "", (if methodSynchronized method then "synchronized " else ""), "", (if methodNative method then "native " else ""), "", (if methodFinal method then "final " else ""), "", (fJavaSignature argsInfo), " -> ", (fJavaReturnType argsInfo), "@"]
{-# LINE 211 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

            thisArg = if isStatic then "" else ((\_ -> let { __ = 
{-# LINE 213 "CodeGen/JavaBindings.hss" #-}
concat ["    ", (head args), "' <- JNI.asObject ", (head args), "\n"]
{-# LINE 213 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
            readArgs = concatMap (("    " ++) . uncurry readArg)
                                 (zip argsNotThis (map fst $ methodParams method))

        return ((\_ -> let { __ = 
{-# LINE 217 "CodeGen/JavaBindings.hss" #-}
concat ["{- | ", (haddock), " -}\n", (name), " :: ", (fSignature argsInfo), "\n", (name), "", (concatMap (' ':) args), " = do\n    (P.Just clazz) <- JNI.getClass \"", (className), "\"\n    (P.Just method) <- clazz `JNI.", (getMethod), "` ", (fJniSignature argsInfo), "\n", (thisArg), "", (readArgs), "    result <- JNI.", (callMethod), " method ", (concatMap (++ "' ") args), "\n    ", (convertResult (fst (methodReturnType method))), " result\n\n"]
{-# LINE 227 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

    fieldDeclarations <- fmap concat $ forM fields $ \(field, (getterName, setterName)) -> do

        let isStatic = fieldStatic field
            jniType  = printJniType $ fst $ fieldType field
            (getField, readField, writeField) = case isStatic of
                True  -> ("getStaticField", "readStaticField", "writeStaticField")
                False -> ("getField",       "readField",       "writeField")

            getterInfo = runTypomatic infoFunc (getterType clazz field modFunc)
            setterInfo = runTypomatic infoFunc (setterType clazz field modFunc)

            getterArgs = fArgNames getterInfo
            getterArgsNotThis = (if isStatic then id else tail) getterArgs

            setterArgs = fArgNames setterInfo
            setterArgsNotThis = (if isStatic then id else tail) setterArgs

            thisArg = if isStatic then ""
                else ((\_ -> let { __ = 
{-# LINE 247 "CodeGen/JavaBindings.hss" #-}
concat ["    ", (head getterArgs), "' <- JNI.asObject ", (head getterArgs), "\n"]
{-# LINE 247 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

            getter = ((\_ -> let { __ = 
{-# LINE 249 "CodeGen/JavaBindings.hss" #-}
concat ["", (getterName), " :: ", (fSignature getterInfo), "\n", (getterName), "", (concatMap (' ':) getterArgs), " = do\n    (P.Just clazz) <- JNI.getClass \"", (className), "\"\n    (P.Just field) <- JNI.", (getField), " clazz \"", (fieldName field), "\" (", (jniType), ")\n", (thisArg), "    result <- JNI.", (readField), " field ", (concatMap (++ "' ") getterArgs), "\n    ", (convertResult (Just (fst (fieldType field)))), " (P.Right result)\n\n"]
{-# LINE 257 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
            setter
                | (Just name) <- setterName = ((\_ -> let { __ = 
{-# LINE 259 "CodeGen/JavaBindings.hss" #-}
concat ["", (name), " :: ", (fSignature setterInfo), "\n", (name), "", (concatMap (' ':) setterArgs), " = do\n    (P.Just clazz) <- JNI.getClass \"", (className), "\"\n    (P.Just field) <- JNI.", (getField), " clazz \"", (fieldName field), "\" (", (jniType), ")\n", (thisArg), "    JNI.", (writeField), " field ", (concatMap (++ "' ") setterArgs), "\n    return ()\n\n"]
{-# LINE 267 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
                | otherwise = ""

        return $ getter ++ setter

    return ((\_ -> let { __ = 
{-# LINE 272 "CodeGen/JavaBindings.hss" #-}
concat ["{-# LANGUAGE Haskell2010 #-}\n-- | ", (moduleComment), "\nmodule ", (moduleName), " (\n", (moduleExports), ") where\n", (commonImports), "\n", (moduleImports), "\n", (constrDeclarations), "\n", (methodDeclarations), "\n", (fieldDeclarations), "\n"]
{-# LINE 283 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)


javaClassModule' :: (Functor m, Monad m) => String -> CodeGenerator m
-- ^ java.lang.Thread -> Java.Lang.Thread__ (interface file)
javaClassModule' className = do

    clazz <- getClassInfoFor className
    moduleName <- getModNameForClass className
    baseName <- moduleName =>> takeClassName

    commonImports <- imports
    moduleImports <- getClassModulesUniq (classParents clazz ++ classIfaces clazz)
        >>= return . concatMap (\name -> "import qualified " ++ name ++ "__\n")

    moduleComment <- return ((\_ -> let { __ = 
{-# LINE 298 "CodeGen/JavaBindings.hss" #-}
concat ["See \"", (moduleName), "\" for the available methods."]
{-# LINE 298 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

    let params = concatMap (\(p:ps) -> ' ' : C.toLower p : ps)
                  $ map (tyVarName . paramName) $ classTypeParams clazz

        newtTDecl = newtTName baseName ++ params
        newtCDecl = newtCName baseName
        dataTDecl = dataTName baseName ++ params
        dataCDecl = dataCName baseName ++ params

        parentInstance parent = do
            modName <- getModNameForClass parent
            let qualifiedName = modName ++ "__." ++ (tyclTName $ takeClassName modName)
            return ((\_ -> let { __ = 
{-# LINE 311 "CodeGen/JavaBindings.hss" #-}
concat ["instance ", (qualifiedName), " (", (newtTDecl), ")\n"]
{-# LINE 311 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

        parentContext parent = do
            modName <- getModNameForClass parent
            let qualifiedName = modName ++ "__." ++ (tyclTName $ takeClassName modName)            
            return ((\_ -> let { __ = 
{-# LINE 316 "CodeGen/JavaBindings.hss" #-}
concat [", ", (qualifiedName), " this"]
{-# LINE 316 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

    context   <- concat <$> mapM parentContext  (classParents clazz)
    instances <- concat <$> mapM parentInstance (classParents clazz)

    let tyclTDecl = ((\_ -> let { __ = 
{-# LINE 321 "CodeGen/JavaBindings.hss" #-}
concat ["(JNI.JavaObject this", (context), ") => ", (tyclTName baseName), " this"]
{-# LINE 321 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

        enumConstants = map sanitize $ map snd $ classEnumConstants clazz
          where sanitize (x:xs) = C.toUpper x : xs

        newtAdditions
            | classEnum clazz = enumConstants
            | otherwise = []

        newtDeclaration
            | null newtAdditions = ((\_ -> let { __ = 
{-# LINE 331 "CodeGen/JavaBindings.hss" #-}
concat ["newtype ", (newtTDecl), " = ", (newtCDecl), " JNI.JObject"]
{-# LINE 331 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
            | otherwise = ((\_ -> let { __ = 
{-# LINE 332 "CodeGen/JavaBindings.hss" #-}
concat ["data ", (newtTDecl), " = ", (newtCDecl), " JNI.JObject"]
{-# LINE 332 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
                ++ concatMap (" | " ++ ) newtAdditions

        newtExport
            | null newtAdditions = ""
            | otherwise = concat (" (" : L.intersperse ", " newtAdditions ++ [")"])

        moduleExports = ((\_ -> let { __ = 
{-# LINE 339 "CodeGen/JavaBindings.hss" #-}
concat ["", (tyclTName baseName), ",\n", (dataTName baseName), " (..),\n", (newtTName baseName), "", (newtExport), ",\n"]
{-# LINE 343 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

        javaObjectInstance
            | classEnum clazz = ((\_ -> let { __ = 
{-# LINE 346 "CodeGen/JavaBindings.hss" #-}
concat ["instance JNI.JavaObject (", (newtTDecl), ") where\n    asObject (", (newtCName baseName), " obj) = return obj\n", (concatMap (uncurry asObjectMatch) $ zip enumConstants $ classEnumConstants clazz), ""]
{-# LINE 349 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
            | otherwise = ((\_ -> let { __ = 
{-# LINE 350 "CodeGen/JavaBindings.hss" #-}
concat ["instance JNI.JavaObject (", (newtTDecl), ") where\n    asObject (", (newtCName baseName), " obj) = return obj"]
{-# LINE 352 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
          where
            asObjectMatch enum (ord, name) = ((\_ -> let { __ = 
{-# LINE 354 "CodeGen/JavaBindings.hss" #-}
concat ["    asObject ", (enum), " = do\n        -- ", (show ord), ", ", (name), "\n        (P.Just clazz) <- JNI.getClass \"", (className), "\"\n        (P.Just field) <- JNI.getStaticField clazz \"", (name), "\" (JNI.object \"", (className), "\")\n        (P.Just object) <- JNI.readStaticField field\n        return object\n"]
{-# LINE 361 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

        moduleDeclarations = ((\_ -> let { __ = 
{-# LINE 363 "CodeGen/JavaBindings.hss" #-}
concat ["class ", (tyclTDecl), "\n", (newtDeclaration), "\ndata ", (dataTDecl), " = ", (dataCDecl), "\n\n", (javaObjectInstance), "\n\ninstance JNIS.UnsafeCast (", (newtTDecl), ") where\n    unsafeFromJObject obj = return (", (newtCDecl), " obj)\n\ninstance ", (tyclTName baseName), " (", (newtTDecl), ")\n\ninstance JNIS.InstanceOf (", (dataTDecl), ") where\n    type CoercedType (", (dataTDecl), ") = (", (newtTDecl), ")\n    coerce o t = do\n        obj <- JNI.asObject o\n        (P.Just clazz) <- JNI.getClass \"", (className), "\"\n        isInstanceOf <- obj `JNI.isInstanceOf` clazz\n        if isInstanceOf\n            then P.Just <$> (JNIS.unsafeFromJObject obj)\n            else return P.Nothing\n\n", (instances), "\n"]
{-# LINE 386 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)

    additionalDeclarations <- case className of
        "java.lang.String" -> return ((\_ -> let { __ = 
{-# LINE 389 "CodeGen/JavaBindings.hss" #-}
concat ["instance JNI.JavaObject [P.Char] where\n    asObject s = do\n        (P.Just clazz) <- JNI.getClass \"java.lang.String\"\n        (P.Just valueOf) <- clazz `JNI.getStaticMethod` \"valueOf\" ::= JNI.string --> JNI.object \"java.lang.String\"\n        (P.Just string) <- JNI.callStaticMethod valueOf s\n        JNI.asObject string\ninstance Java.Lang.Object [P.Char]\ninstance Java.Lang.String [P.Char]\n"]
{-# LINE 398 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        "java.lang.Character" -> return ((\_ -> let { __ = 
{-# LINE 399 "CodeGen/JavaBindings.hss" #-}
concat ["instance JNI.JavaObject P.Char where\n    asObject ...\ninstance Java.Lang.Object P.Char\ninstance Java.Lang.Character P.Char\n"]
{-# LINE 404 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        "java.lang.Boolean" -> return ((\_ -> let { __ = 
{-# LINE 405 "CodeGen/JavaBindings.hss" #-}
concat ["instance JNI.JavaObject P.Bool where\n    asObject n = do\n        (P.Just clazz) <- JNI.getClass \"java.lang.Boolean\"\n        (P.Just valueOf) <- clazz `JNI.getStaticMethod` \"valueOf\"\n                            ::= JNI.byte --> JNI.object \"java.lang.Boolean\"\n        (P.Just boolean) <- JNI.callStaticMethod valueOf n\n        JNI.asObject boolean\ninstance Java.Lang.Object P.Bool\ninstance Java.Lang.Boolean P.Bool\n"]
{-# LINE 415 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        "java.lang.Number" -> return ((\_ -> let { __ = 
{-# LINE 416 "CodeGen/JavaBindings.hss" #-}
concat ["            import qualified Data.Int\n            import qualified Data.Word\n            instance JNI.JavaObject Data.Int.Int8 where\n                asObject n = do\n                    (P.Just clazz) <- JNI.getClass \"java.lang.Byte\"\n                    (P.Just valueOf) <- clazz `JNI.getStaticMethod` \"valueOf\"\n                                        ::= JNI.byte --> JNI.object \"java.lang.Byte\"\n                    (P.Just number) <- JNI.callStaticMethod valueOf n\n                    JNI.asObject number\n            instance JNI.JavaObject Data.Int.Int16 where\n                asObject n = do\n                    (P.Just clazz) <- JNI.getClass \"java.lang.Short\"\n                    (P.Just valueOf) <- clazz `JNI.getStaticMethod` \"valueOf\"\n                                        ::= JNI.short --> JNI.object \"java.lang.Short\"\n                    (P.Just number) <- JNI.callStaticMethod valueOf n\n                    JNI.asObject number\n            instance JNI.JavaObject Data.Int.Int32 where\n                asObject n = do\n                    (P.Just clazz) <- JNI.getClass \"java.lang.Integer\"\n                    (P.Just valueOf) <- clazz `JNI.getStaticMethod` \"valueOf\"\n                                        ::= JNI.int --> JNI.object \"java.lang.Integer\"\n                    (P.Just number) <- JNI.callStaticMethod valueOf n\n                    JNI.asObject number\n            instance JNI.JavaObject Data.Int.Int64 where\n                asObject n = do\n                    (P.Just clazz) <- JNI.getClass \"java.lang.Long\"\n                    (P.Just valueOf) <- clazz `JNI.getStaticMethod` \"valueOf\"\n                                        ::= JNI.long --> JNI.object \"java.lang.Long\"\n                    (P.Just number) <- JNI.callStaticMethod valueOf n\n                    JNI.asObject number\n\n            instance Java.Lang.Object P.Int\n            instance Java.Lang.Number P.Int\n            instance Java.Lang.Object Data.Int.Int8\n            instance Java.Lang.Number Data.Int.Int8\n            instance Java.Lang.Object Data.Int.Int16\n            instance Java.Lang.Number Data.Int.Int16\n            instance Java.Lang.Object Data.Int.Int32\n            instance Java.Lang.Number Data.Int.Int32\n            instance Java.Lang.Object Data.Int.Int64\n            instance Java.Lang.Number Data.Int.Int64\n            "]
{-# LINE 458 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        "java.lang.Byte" -> return ((\_ -> let { __ = 
{-# LINE 459 "CodeGen/JavaBindings.hss" #-}
concat ["import qualified Data.Int\nimport qualified Data.Word\ninstance Java.Lang.Byte Data.Int\n"]
{-# LINE 463 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        "java.lang.Short" -> return ((\_ -> let { __ = 
{-# LINE 464 "CodeGen/JavaBindings.hss" #-}
concat ["import qualified Data.Int\nimport qualified Data.Word\ninstance Java.Lang.Short Data.Int\n"]
{-# LINE 468 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        "java.lang.Integer" -> return ((\_ -> let { __ = 
{-# LINE 469 "CodeGen/JavaBindings.hss" #-}
concat ["import qualified Data.Int\nimport qualified Data.Word\ninstance Java.Lang.Integer Data.Int\n"]
{-# LINE 473 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        "java.lang.Long" -> return ((\_ -> let { __ = 
{-# LINE 474 "CodeGen/JavaBindings.hss" #-}
concat ["import qualified Data.Int\nimport qualified Data.Word\ninstance Java.Lang.Long Data.Int\n"]
{-# LINE 478 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        "java.lang.Float" -> return ((\_ -> let { __ = 
{-# LINE 479 "CodeGen/JavaBindings.hss" #-}
concat ["import qualified Data.Int\nimport qualified Data.Word\ninstance Java.Lang.Float Data.Int\n"]
{-# LINE 483 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)
        "java.lang.Double" -> return ((\_ -> let { __ = 
{-# LINE 484 "CodeGen/JavaBindings.hss" #-}
concat ["import qualified Data.Int\nimport qualified Data.Word\ninstance Java.Lang.Double Data.Int\n"]
{-# LINE 488 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)


    return ((\_ -> let { __ = 
{-# LINE 491 "CodeGen/JavaBindings.hss" #-}
concat ["{-# LANGUAGE Haskell2010, TypeFamilies, FlexibleInstances #-}\n-- | ", (moduleComment), "\nmodule ", (moduleName), "__ (\n", (moduleExports), "\n) where\n", (commonImports), "\n", (moduleImports), "\n", (additionalDeclarations), "\n", (moduleDeclarations), "\n"]
{-# LINE 501 "CodeGen/JavaBindings.hss" #-}
} in __) undefined)