Comprehensive comparison for AI technology in applications

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveGeneric #-}

module AI.SentimentAnalysis where

import qualified Data.Text as T
import Data.Aeson (FromJSON, ToJSON, encode, decode)
import GHC.Generics (Generic)
import Network.HTTP.Client
import Network.HTTP.Client.TLS (tlsManagerSettings)
import Control.Exception (try, SomeException)
import Data.Maybe (fromMaybe)
import qualified Data.ByteString.Lazy as BL

-- | Data model for sentiment analysis request
data SentimentRequest = SentimentRequest
  { text :: T.Text
  , language :: Maybe T.Text
  } deriving (Show, Generic)

instance ToJSON SentimentRequest
instance FromJSON SentimentRequest

-- | Data model for sentiment analysis response
data SentimentResponse = SentimentResponse
  { sentiment :: T.Text
  , confidence :: Double
  , scores :: SentimentScores
  } deriving (Show, Generic)

data SentimentScores = SentimentScores
  { positive :: Double
  , negative :: Double
  , neutral :: Double
  } deriving (Show, Generic)

instance ToJSON SentimentResponse
instance FromJSON SentimentResponse
instance ToJSON SentimentScores
instance FromJSON SentimentScores

-- | Configuration for AI service
data AIConfig = AIConfig
  { apiEndpoint :: String
  , apiKey :: T.Text
  , timeout :: Int
  } deriving (Show)

-- | Result type for error handling
data AnalysisResult = Success SentimentResponse
                    | NetworkError String
                    | ParseError String
                    | ValidationError String
                    deriving (Show)

-- | Validate input text before sending to AI service
validateInput :: SentimentRequest -> Either String SentimentRequest
validateInput req
  | T.null (text req) = Left "Text cannot be empty"
  | T.length (text req) > 5000 = Left "Text exceeds maximum length of 5000 characters"
  | otherwise = Right req

-- | Analyze sentiment using external AI API
analyzeSentiment :: AIConfig -> SentimentRequest -> IO AnalysisResult
analyzeSentiment config req = do
  case validateInput req of
    Left err -> return $ ValidationError err
    Right validReq -> performAnalysis config validReq

-- | Perform the actual API call
performAnalysis :: AIConfig -> SentimentRequest -> IO AnalysisResult
performAnalysis config req = do
  manager <- newManager tlsManagerSettings
  initialRequest <- parseRequest (apiEndpoint config)
  
  let request = initialRequest
        { method = "POST"
        , requestBody = RequestBodyLBS $ encode req
        , requestHeaders = 
            [ ("Content-Type", "application/json")
            , ("Authorization", "Bearer " <> (T.encodeUtf8 $ apiKey config))
            ]
        , responseTimeout = responseTimeoutMicro (timeout config * 1000000)
        }
  
  result <- try $ httpLbs request manager :: IO (Either SomeException (Response BL.ByteString))
  
  case result of
    Left ex -> return $ NetworkError (show ex)
    Right response -> parseResponse (responseBody response)

-- | Parse API response with error handling
parseResponse :: BL.ByteString -> IO AnalysisResult
parseResponse body = 
  case decode body :: Maybe SentimentResponse of
    Nothing -> return $ ParseError "Failed to parse API response"
    Just sentiment -> return $ Success sentiment

-- | Batch process multiple texts
batchAnalyze :: AIConfig -> [SentimentRequest] -> IO [AnalysisResult]
batchAnalyze config requests = mapM (analyzeSentiment config) requests

-- | Extract dominant sentiment with fallback
getDominantSentiment :: AnalysisResult -> T.Text
getDominantSentiment (Success response) = sentiment response
getDominantSentiment _ = "unknown"

-- | Example usage
exampleUsage :: IO ()
exampleUsage = do
  let config = AIConfig
        { apiEndpoint = "https://api.example.com/v1/sentiment"
        , apiKey = "your-api-key-here"
        , timeout = 30
        }
  
  let request = SentimentRequest
        { text = "This product is absolutely amazing! I love it."
        , language = Just "en"
        }
  
  result <- analyzeSentiment config request
  
  case result of
    Success response -> do
      putStrLn $ "Sentiment: " ++ T.unpack (sentiment response)
      putStrLn $ "Confidence: " ++ show (confidence response)
      putStrLn $ "Positive score: " ++ show (positive $ scores response)
    NetworkError err -> putStrLn $ "Network error: " ++ err
    ParseError err -> putStrLn $ "Parse error: " ++ err
    ValidationError err -> putStrLn $ "Validation error: " ++ err