content: {-# LANGUAGE OverloadedStrings #-}
  
  module Test.Ollama.Common (tests) where
  
  import Data.Ollama.Common.SchemaBuilder
  import Data.Ollama.Common.Utils (encodeImage)
  import Data.Text qualified as T
  import Test.Tasty
  import Test.Tasty.HUnit
  
  -- Test SchemaBuilder functionality
  testSchemaBuilderBasic :: TestTree
  testSchemaBuilderBasic = testCase "SchemaBuilder: basic object construction" $ do
    let schema =
          buildSchema $
            emptyObject
              |+ ("name", JString)
              |+ ("age", JNumber)
              |! "name"
              |! "age"
  
    -- Check that schema is not null/empty
    let schemaText = T.pack $ show schema
    assertBool "Schema should not be empty" (not $ T.null schemaText)
    assertBool "Schema should contain 'name'" ("name" `T.isInfixOf` schemaText)
    assertBool "Schema should contain 'age'" ("age" `T.isInfixOf` schemaText)
  
  testSchemaBuilderArray :: TestTree
  testSchemaBuilderArray = testCase "SchemaBuilder: array types" $ do
    let arraySchema =
          buildSchema $
            emptyObject
              |+ ("items", JArray JString)
              |+ ("numbers", JArray JNumber)
              |+ ("flags", JArray JBoolean)
              |! "items"
  
    let schemaText = T.pack $ show arraySchema
    assertBool "Array schema should not be empty" (not $ T.null schemaText)
    assertBool "Should contain items field" ("items" `T.isInfixOf` schemaText)
  
  testSchemaBuilderOptionalFields :: TestTree
  testSchemaBuilderOptionalFields = testCase "SchemaBuilder: optional vs required fields" $ do
    let schema =
          buildSchema $
            emptyObject
              |+ ("required_field", JString)
              |+ ("optional_field", JString)
              |! "required_field"
  
    let schemaText = T.pack $ show schema
    assertBool "Schema should contain both fields" $
      "required_field" `T.isInfixOf` schemaText
        && "optional_field" `T.isInfixOf` schemaText
  
  -- Test image encoding utility
  testEncodeImageValidFile :: TestTree
  testEncodeImageValidFile = testCase "EncodeImage: should handle existing image file" $ do
    -- Test with the sample image from the examples
    result <- encodeImage "./examples/sample.png"
    case result of
      Nothing -> return () -- File might not exist in test environment
      Just encoded -> do
        assertBool "Encoded image should not be empty" (not $ T.null encoded)
        assertBool "Should be base64-like content" (T.length encoded > 10)
  
  testEncodeImageNonExistentFile :: TestTree
  testEncodeImageNonExistentFile = testCase "EncodeImage: should return Nothing for non-existent file" $ do
    result <- encodeImage "./nonexistent/file.png"
    case result of
      Nothing -> assertBool "Should return Nothing for non-existent file" True
      Just _ -> assertFailure "Should not encode non-existent file"
  
  testEncodeImageInvalidFormat :: TestTree
  testEncodeImageInvalidFormat = testCase "EncodeImage: should handle invalid file format" $ do
    result <- encodeImage "./test/Main.hs" -- Text file, not an image
    case result of
      Nothing -> assertBool "Should return Nothing for invalid format" True
      Just _ -> assertFailure "Should not encode invalid format"
  
  tests :: TestTree
  tests =
    testGroup
      "Common utilities tests"
      [ testSchemaBuilderBasic
      , testSchemaBuilderArray
      , testSchemaBuilderOptionalFields
      , testEncodeImageValidFile
      , testEncodeImageNonExistentFile
      , testEncodeImageInvalidFormat
      ]
  