toilet_tracker 0.1.0

data/lib/toilet_tracker/parsers/base_parser.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ToiletTracker
+  module Parsers
+    class BaseParser
+      attr_reader :config
+
+      def initialize(config = ToiletTracker.configuration)
+        @config = config
+      end
+
+      def parse(input)
+        raise NotImplementedError, 'Subclasses must implement #parse'
+      end
+
+      def valid?(input)
+        raise NotImplementedError, 'Subclasses must implement #valid?'
+      end
+
+      protected
+
+      def clean_content(content)
+        content.to_s.gsub(config.edited_message_suffix, '').strip
+      end
+
+      def parse_shift(shift_string)
+        return nil if shift_string.nil? || shift_string.empty?
+
+        shift = Integer(shift_string)
+        raise Core::InvalidShift, shift_string unless config.valid_shift?(shift)
+
+        shift
+      rescue ArgumentError
+        raise Core::InvalidShift, shift_string
+      end
+
+      def parse_datetime(datetime_string)
+        return nil if datetime_string.nil? || datetime_string.empty?
+
+        config.date_formats.each do |format|
+          return config.default_timezone_object.strptime(datetime_string, format)
+        rescue ArgumentError
+          next
+        end
+
+        # Fallback to timezone-aware parse
+        config.default_timezone_object.parse(datetime_string)
+      rescue ArgumentError
+        raise Core::InvalidDateTime, datetime_string
+      end
+
+      def determine_status(event_time, message_time)
+        return :error unless event_time && message_time
+
+        time_diff = (message_time - event_time).abs
+        time_diff > 30.days ? :alert : :ok
+      end
+    end
+  end
+end

data/lib/toilet_tracker/parsers/message_parser.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module ToiletTracker
+  module Parsers
+    class MessageParser < BaseParser
+      def parse(message)
+        return Core::Result.failure(ArgumentError.new('Message required')) unless message.is_a?(Core::Message)
+        return Core::Result.failure(ArgumentError.new('Invalid message')) unless message.valid?
+
+        content = message.content.strip
+
+        # Try to match patterns
+        matched_result = try_pattern_matching(content, message)
+        return matched_result if matched_result
+
+        # Handle unmatched emoji content
+        handle_unmatched_content(content)
+      end
+
+      def valid?(message)
+        return false unless message.is_a?(Core::Message) && message.valid?
+
+        content = message.content.strip
+        config.message_patterns.any? { |_, pattern| pattern.match?(content) }
+      end
+
+      private
+
+      def try_pattern_matching(content, message)
+        config.message_patterns.each do |type, pattern|
+          match = pattern.match(content)
+          next unless match
+
+          begin
+            result = parse_by_type(type, match, message)
+            return Core::Result.success(result)
+          rescue Core::Error => e
+            return Core::Result.failure(e)
+          end
+        end
+
+        nil
+      end
+
+      def handle_unmatched_content(content)
+        if content.include?('🚽') || content.include?('💩')
+          error = Core::InvalidMessageFormat.new(content, 'valid emoji pattern')
+          return Core::Result.failure(error)
+        end
+
+        # Not a toilet tracking message
+        Core::Result.success(nil)
+      end
+
+      def parse_by_type(type, match, message)
+        case type
+        when :shift_set, :shift_set_at_time, :timezone_set
+          parse_toilet_type(type, match, message)
+        when :event_now, :event_now_shifted, :event_at_time, :event_at_time_shifted,
+             :event_in_timezone, :event_in_timezone_at_time
+          parse_poop_type(type, match, message)
+        else
+          raise Core::ParseError, "Unknown message type: #{type}"
+        end
+      end
+
+      def parse_toilet_type(type, match, message)
+        case type
+        when :shift_set
+          parse_toilet_shift(match, message)
+        when :shift_set_at_time
+          parse_toilet_shift_with_time(match, message)
+        when :timezone_set
+          parse_toilet_timezone(match, message)
+        end
+      end
+
+      def parse_poop_type(type, match, message)
+        case type
+        when :event_now
+          parse_poop_live(message)
+        when :event_now_shifted
+          parse_poop_live_shift(match, message)
+        when :event_at_time
+          parse_poop_past(match, message)
+        when :event_at_time_shifted
+          parse_poop_past_with_shift(match, message)
+        when :event_in_timezone
+          parse_poop_timezone(match, message)
+        when :event_in_timezone_at_time
+          parse_poop_timezone_with_time(match, message)
+        end
+      end
+
+      def parse_toilet_shift(match, message)
+        shift = parse_shift(match[1])
+
+        Core::ToiletShiftResult.new(
+          type: :shift_set,
+          status: :ok,
+          message: message,
+          shift: shift,
+          effective_time: message.timestamp
+        )
+      end
+
+      def parse_toilet_shift_with_time(match, message)
+        shift = parse_shift(match[1])
+        effective_time = parse_datetime(match[2])
+
+        status = determine_status(effective_time, message.timestamp)
+
+        Core::ToiletShiftResult.new(
+          type: :shift_set_at_time,
+          status: status,
+          message: message,
+          shift: shift,
+          effective_time: effective_time
+        )
+      end
+
+      def parse_toilet_timezone(match, message)
+        timezone_str = match[1]
+
+        Core::TimezoneResult.new(
+          type: :timezone_set,
+          status: :ok,
+          message: message,
+          timezone: timezone_str
+        )
+      end
+
+      def parse_poop_live(message)
+        Core::PoopEventResult.new(
+          type: :event_now,
+          status: :ok,
+          message: message,
+          shift: 0,
+          poop_time: message.timestamp
+        )
+      end
+
+      def parse_poop_live_shift(match, message)
+        shift = parse_shift(match[1])
+
+        Core::PoopEventResult.new(
+          type: :event_now_shifted,
+          status: :ok,
+          message: message,
+          shift: shift,
+          poop_time: message.timestamp
+        )
+      end
+
+      def parse_poop_past(match, message)
+        poop_time = parse_datetime(match[1])
+        status = determine_status(poop_time, message.timestamp)
+
+        Core::PoopEventResult.new(
+          type: :event_at_time,
+          status: status,
+          message: message,
+          shift: 0,
+          poop_time: poop_time
+        )
+      end
+
+      def parse_poop_past_with_shift(match, message)
+        shift = parse_shift(match[1])
+        poop_time = parse_datetime(match[2])
+        status = determine_status(poop_time, message.timestamp)
+
+        Core::PoopEventResult.new(
+          type: :event_at_time_shifted,
+          status: status,
+          message: message,
+          shift: shift,
+          poop_time: poop_time
+        )
+      end
+
+      def parse_poop_timezone(match, message)
+        timezone_str = match[1]
+
+        Core::PoopEventResult.new(
+          type: :event_in_timezone,
+          status: :ok,
+          message: message,
+          poop_time: message.timestamp,
+          timezone: timezone_str
+        )
+      end
+
+      def parse_poop_timezone_with_time(match, message)
+        timezone_str = match[1]
+        poop_time = parse_datetime(match[2])
+        status = determine_status(poop_time, message.timestamp)
+
+        Core::PoopEventResult.new(
+          type: :event_in_timezone_at_time,
+          status: status,
+          message: message,
+          poop_time: poop_time,
+          timezone: timezone_str
+        )
+      end
+    end
+  end
+end

data/lib/toilet_tracker/parsers/whatsapp_parser.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ToiletTracker
+  module Parsers
+    class WhatsappParser < BaseParser
+      def parse(line)
+        match = config.whatsapp_message_pattern.match(line)
+        return failure_for_invalid_format(line) unless match
+
+        begin
+          message = build_message_from_match(match)
+          return failure_for_invalid_sender(line) unless message.valid?
+
+          Core::Result.success(message)
+        rescue StandardError => e
+          Core::Result.failure(e)
+        end
+      end
+
+      def valid?(line)
+        config.whatsapp_message_pattern.match?(line)
+      end
+
+      private
+
+      def failure_for_invalid_format(line)
+        Core::Result.failure(Core::InvalidMessageFormat.new(line, 'WhatsApp format'))
+      end
+
+      def failure_for_invalid_sender(line)
+        Core::Result.failure(Core::InvalidMessageFormat.new(line, 'Empty sender'))
+      end
+
+      def build_message_from_match(match)
+        timestamp = parse_whatsapp_timestamp(match[:day], match[:month], match[:year], match[:time])
+        Core::Message.new(
+          timestamp: timestamp,
+          sender: match[:sender].strip,
+          content: clean_content(match[:content])
+        )
+      end
+
+      def parse_whatsapp_timestamp(day, month, year, time)
+        # Convert YY to full year (assuming 2000s)
+        full_year = "20#{year}"
+        datetime_string = "#{day}/#{month}/#{full_year} #{time}"
+
+        # Parse in the default timezone
+        config.default_timezone_object.strptime(datetime_string, '%d/%m/%Y %H:%M:%S')
+      rescue ArgumentError => e
+        raise Core::InvalidDateTime, "#{day}/#{month}/#{year} #{time}: #{e.message}"
+      end
+
+      def clean_content(content)
+        return '' if content.nil?
+
+        # Remove the "This message was edited" suffix
+        content.gsub(config.edited_message_suffix, '').strip
+      end
+    end
+  end
+end

data/lib/toilet_tracker/services/analysis_service.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module ToiletTracker
+  module Services
+    class AnalysisService
+      attr_reader :whatsapp_parser, :message_parser, :shift_service, :timezone_service
+
+      def initialize(
+        whatsapp_parser: Parsers::WhatsappParser.new,
+        message_parser: Parsers::MessageParser.new,
+        shift_service: ShiftService.new,
+        timezone_service: TimezoneService.new
+      )
+        @whatsapp_parser = whatsapp_parser
+        @message_parser = message_parser
+        @shift_service = shift_service
+        @timezone_service = timezone_service
+      end
+
+      def analyze_lines(lines)
+        # Parse all lines first
+        results = lines.filter_map { |line| analyze_line(line) }
+
+        # Apply retroactive shifts
+        apply_retroactive_shifts_to_results(results)
+      end
+
+      def analyze_line(line)
+        # Parse WhatsApp line format first
+        whatsapp_result = whatsapp_parser.parse(line)
+        return create_error_result(whatsapp_result.error, line) if whatsapp_result.failure?
+
+        message = whatsapp_result.value
+
+        # Parse message content for toilet tracking commands
+        message_result = message_parser.parse(message)
+        return create_error_result(message_result.error, line) if message_result.failure?
+
+        parsed_result = message_result.value
+        return nil unless parsed_result # Not a toilet tracking message
+
+        # Process the parsed result
+        process_parsed_result(parsed_result)
+      end
+
+      def analyze_messages(messages, apply_retroactive_shifts: true)
+        results = []
+
+        # First pass: process all messages and build shift history
+        messages.each do |message|
+          message_result = message_parser.parse(message)
+          next if message_result.failure? || message_result.value.nil?
+
+          result = process_parsed_result(message_result.value)
+          results << result if result
+        end
+
+        # Second pass: apply retroactive shifts to poop events if enabled
+        results = apply_retroactive_shifts_to_results(results) if apply_retroactive_shifts
+
+        results
+      end
+
+      private
+
+      def process_parsed_result(parsed_result)
+        case parsed_result
+        when Core::ToiletShiftResult
+          process_toilet_shift(parsed_result)
+        when Core::TimezoneResult
+          process_timezone_setting(parsed_result)
+        when Core::PoopEventResult
+          process_poop_event(parsed_result)
+        else
+          parsed_result
+        end
+      end
+
+      def process_toilet_shift(result)
+        user = result.message.sender
+        effective_time = result.effective_time || result.message.timestamp
+
+        # Use retroactive shift if effective time is earlier than message time
+        if result.effective_time && result.effective_time < result.message.timestamp
+          shift_service.set_retroactive_shift(user, result.shift, effective_time)
+        else
+          shift_service.set_shift(user, result.shift, effective_time)
+        end
+
+        result
+      rescue Core::Error => e
+        create_error_from_result(result, e)
+      end
+
+      def process_timezone_setting(result)
+        user = result.message.sender
+        effective_time = result.message.timestamp
+
+        begin
+          shift_service.set_timezone(user, result.timezone, effective_time)
+
+          # Calculate the actual shift for the result
+          shift = timezone_service.calculate_shift(
+            ToiletTracker.configuration.default_timezone,
+            result.timezone,
+            effective_time
+          )
+
+          Core::ToiletShiftResult.new(
+            type: :timezone_shift,
+            status: :ok,
+            message: result.message,
+            shift: shift,
+            effective_time: effective_time
+          )
+        rescue Core::Error => e
+          create_error_from_result(result, e)
+        end
+      end
+
+      def process_poop_event(result)
+        user = result.message.sender
+
+        case result.type
+        when :event_now
+          process_poop_live(result, user)
+        when :event_now_shifted
+          process_poop_live_shift(result)
+        when :event_in_timezone
+          process_poop_timezone(result, user)
+        else
+          process_poop_with_explicit_time(result, user)
+        end
+      end
+
+      def process_poop_live(result, user)
+        active_shift = shift_service.get_active_shift(user, result.message.timestamp)
+        adjusted_time = timezone_service.apply_shift(result.message.timestamp, active_shift)
+        result.with(shift: active_shift, poop_time: adjusted_time)
+      end
+
+      def process_poop_live_shift(result)
+        adjusted_time = timezone_service.apply_shift(result.message.timestamp, result.shift)
+        result.with(poop_time: adjusted_time)
+      end
+
+      def process_poop_timezone(result, _user)
+        shift = timezone_service.calculate_shift(
+          ToiletTracker.configuration.default_timezone,
+          result.timezone,
+          result.message.timestamp
+        )
+        adjusted_time = timezone_service.apply_shift(result.message.timestamp, shift)
+        result.with(shift: shift, poop_time: adjusted_time)
+      rescue Core::Error => e
+        create_error_from_result(result, e)
+      end
+
+      def process_poop_with_explicit_time(result, user)
+        case result.type
+        when :event_at_time
+          # Record active shift for reference
+          active_shift = shift_service.get_active_shift(user, result.poop_time)
+          result.with(shift: active_shift)
+        when :event_at_time_shifted, :event_in_timezone_at_time
+          # These have decorative shifts/timezones - preserve them as-is
+          # poop_time remains unchanged, shift/timezone are for display only
+          result
+        else
+          result
+        end
+      end
+
+      def apply_retroactive_shifts_to_results(results)
+        # Only adjust poop_live events that don't have explicit shifts
+        results.map do |result|
+          next result unless should_apply_retroactive_shift?(result)
+
+          user = result.message.sender
+          correct_shift = shift_service.get_active_shift(user, result.message.timestamp)
+
+          if correct_shift == result.shift
+            result
+          else
+            adjusted_time = timezone_service.apply_shift(result.message.timestamp, correct_shift)
+            result.with(shift: correct_shift, poop_time: adjusted_time)
+          end
+        end
+      end
+
+      def should_apply_retroactive_shift?(result)
+        result.is_a?(Core::PoopEventResult) &&
+          result.type == :event_now &&
+          result.status != :error
+      end
+
+      def create_error_result(error, original_line = nil)
+        Core::ParseResult.new(
+          type: :parse_error,
+          status: :error,
+          message: nil,
+          error_details: error.message,
+          original_content: original_line
+        )
+      end
+
+      def create_error_from_result(result, error)
+        result.with(status: :error, error_details: error.message)
+      end
+    end
+  end
+end

data/lib/toilet_tracker/services/shift_service.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ToiletTracker
+  module Services
+    class ShiftService
+      ShiftEntry = Data.define(:time, :shift, :timezone)
+
+      attr_reader :timezone_service
+
+      def initialize(timezone_service = TimezoneService.new)
+        @timezone_service = timezone_service
+        @user_shifts = Hash.new { |h, k| h[k] = [default_shift_entry] }
+      end
+
+      def set_shift(user, shift, effective_time = Time.current, timezone = nil)
+        validate_shift!(shift)
+
+        entry = ShiftEntry.new(
+          time: effective_time,
+          shift: shift,
+          timezone: timezone
+        )
+
+        @user_shifts[user] << entry
+        @user_shifts[user].sort_by!(&:time)
+      end
+
+      def set_retroactive_shift(user, shift, effective_time, timezone = nil)
+        validate_shift!(shift)
+
+        entry = ShiftEntry.new(
+          time: effective_time,
+          shift: shift,
+          timezone: timezone
+        )
+
+        # Remove any shifts that were set after this effective time
+        @user_shifts[user].reject! { |existing| existing.time > effective_time }
+
+        @user_shifts[user] << entry
+        @user_shifts[user].sort_by!(&:time)
+      end
+
+      def set_timezone(user, timezone_spec, effective_time = Time.current)
+        timezone = timezone_service.resolve_timezone(timezone_spec)
+        shift = timezone_service.calculate_shift(
+          ToiletTracker.configuration.default_timezone,
+          timezone,
+          effective_time
+        )
+
+        set_shift(user, shift, effective_time, timezone_spec)
+      end
+
+      def get_active_shift(user, at_time = Time.current)
+        history = @user_shifts[user]
+
+        # Find the most recent shift that was set before or at the given time
+        relevant_entry = history.reverse_each.find { |entry| entry.time <= at_time }
+        relevant_entry&.shift || 0
+      end
+
+      def get_shift_history(user)
+        @user_shifts[user].dup
+      end
+
+      def clear_history(user)
+        @user_shifts[user] = [default_shift_entry]
+      end
+
+      def clear_all_history
+        @user_shifts.clear
+      end
+
+      private
+
+      def validate_shift!(shift)
+        return if ToiletTracker.configuration.valid_shift?(shift)
+
+        raise Core::InvalidShift, shift
+      end
+
+      def default_shift_entry
+        # Very old timestamp to ensure it's always the earliest
+        ShiftEntry.new(time: Time.at(0), shift: 0, timezone: nil)
+      end
+    end
+  end
+end