-- |Functions and data for working with Twitter statuses.
module Twitter.Status
where

import Data.Maybe
import Text.XML.HaXml

import Twitter.User
import Twitter.Xml

-- |Represents one Twitter status. We don't care about any of their
-- other properties.
data Status = Status { status_id  :: Integer,
                       created_at :: String,
                       text       :: String,
                       user       :: User }
            deriving (Show, Eq)


-- |Given some XML content, create a 'Status' from it.
status_from_content :: Content -> (Maybe Status)
status_from_content content =

    if (length status_ids) == 0
        || (length created_ats) == 0
        || (length texts) == 0
        || (length users) == 0
    then
        Nothing
    else
        case first_status_id of
          Nothing -> Nothing
          (Just status_id_data) ->
              case first_created_at of
                  Nothing -> Nothing
                  (Just created_at_data) ->
                          case first_user of
                              Nothing -> Nothing
                              (Just user_object) ->
                                  case (reads status_id_data :: [(Integer, String)]) of
                                    []   -> Nothing
                                    parseresult:_ -> Just (Status (fst parseresult) created_at_data all_text user_object)

    where
      status_ids = (unique_id content)
      first_status_id = get_char_data (status_ids !! 0)

      created_ats = (status_created_at content)
      first_created_at = get_char_data (created_ats !! 0)

      texts = (status_text content)
      all_text = concat $ catMaybes (map get_char_data texts)

      users = (status_user content)
      first_user = user_from_content (users !! 0)


-- |Takes an XML String as an argument, and returns the
-- status that was parsed from it. Should only be used
-- on XML string where a <status> is a top-level element.
parse_status :: String -> [Status]
parse_status xml_data =
    catMaybes maybe_status
    where
      (Document _ _ root _) = xmlParse xml_file_name xml_data
      root_elem = CElem root
      status_element = (single_status root_elem)
      maybe_status = map status_from_content status_element


-- |Takes an XML String as an argument, and returns the list of
-- statuses that can be parsed from it.
parse_statuses :: String -> [Status]
parse_statuses xml_data =
    catMaybes maybe_statuses
    where
      (Document _ _ root _) = xmlParse xml_file_name xml_data
      root_elem = CElem root
      status_elements = (all_statuses root_elem)
      maybe_statuses = map status_from_content status_elements


-- |This is a required parameter to the xmlParse function used in
-- error reporting. We're not parsing a function, though, so we leave
-- it blank.
xml_file_name :: String
xml_file_name = ""

-- |Returns a nicely-formatted String representing the given 'Status'
-- object.
pretty_print :: Status -> String
pretty_print status =
    concat [ name,
             " - ",
             (created_at status),
             "\n",
             replicate ((length name) + 3 + (length (created_at status))) '-',
             "\n",
             replace_entities (text status),
             "\n" ]
             where
               name = screen_name (user status)



-- |Given a list of statuses, returns the greatest status_id belonging
-- to one of the statuses in the list.
get_max_status_id :: [Status] -> Integer
get_max_status_id statuses =
  maximum status_ids
  where
    status_ids = map status_id statuses