shoko 0.1.0

data/lib/shoko/core/services/coordinate_service.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require_relative 'base_service'
+require_relative '../models/selection_anchor'
+
+module Shoko
+  module Core
+    module Services
+      # Domain service for coordinate system management with dependency injection.
+      # Migrated from legacy Services::CoordinateService to follow DI pattern.
+      class CoordinateService < BaseService
+        # Convert mouse coordinates (0-based) to terminal coordinates (1-based)
+        def mouse_to_terminal(mouse_x, mouse_y)
+          {
+            x: mouse_x + 1,
+            y: mouse_y + 1,
+          }
+        end
+
+        # Convert terminal coordinates (1-based) to mouse coordinates (0-based)
+        def terminal_to_mouse(terminal_x, terminal_y)
+          {
+            x: [terminal_x - 1, 0].max,
+            y: [terminal_y - 1, 0].max,
+          }
+        end
+
+        # Normalize selection range ensuring start <= end. Accepts either
+        # geometry-based anchors or legacy screen coordinate hashes.
+        #
+        # @param selection_range [Hash]
+        # @param rendered_lines [Hash]
+        # @return [Hash,nil]
+        def normalize_selection_range(selection_range, rendered_lines = nil)
+          return nil unless selection_range
+
+          start_anchor = normalize_anchor(selection_range[:start], rendered_lines)
+          end_anchor = normalize_anchor(selection_range[:end], rendered_lines)
+          return nil unless start_anchor && end_anchor
+
+          start_anchor, end_anchor = end_anchor, start_anchor if (start_anchor <=> end_anchor)&.positive?
+
+          {
+            start: start_anchor.to_h,
+            end: end_anchor.to_h,
+          }
+        end
+
+        # Validate coordinate bounds
+        def validate_coordinates?(col, row, max_col, max_row)
+          col.between?(1, max_col) && row.between?(1, max_row)
+        end
+
+        # Calculate distance between two points
+        def calculate_distance(x_start, y_start, x_end, y_end)
+          Math.sqrt(((x_end - x_start)**2) + ((y_end - y_start)**2))
+        end
+
+        # Calculate optimal popup position near selection end
+        def calculate_popup_position(selection_end, popup_width, popup_height)
+          terminal_height, terminal_width = @dependencies.resolve(:terminal_service).size
+
+          # Start with position below selection end
+          end_y = selection_end[:y]
+          popup_x = selection_end[:x]
+          popup_y = end_y + 1
+
+          # Adjust if popup would go off right edge
+          popup_x = [terminal_width - popup_width, 1].max if popup_x + popup_width > terminal_width
+
+          # Adjust if popup would go off bottom edge
+          if popup_y + popup_height > terminal_height
+            # Try to position above selection instead
+            popup_y = [end_y - popup_height, 1].max
+          end
+
+          {
+            x: popup_x,
+            y: popup_y,
+          }
+        end
+
+        # Check if coordinates are within bounds
+        def within_bounds?(col, row, bounds)
+          bx = bounds.x
+          by = bounds.y
+          bw = bounds.width
+          bh = bounds.height
+          col >= bx && col < (bx + bw) && row >= by && row < (by + bh)
+        end
+
+        # Convert line-relative coordinates to absolute terminal coordinates
+        def line_to_terminal(line_col, line_start_col, terminal_row)
+          {
+            x: line_start_col + line_col,
+            y: terminal_row,
+          }
+        end
+
+        # Normalize position hash to consistent format
+        def normalize_position(pos)
+          return nil unless pos
+
+          {
+            x: pos[:x] || pos['x'],
+            y: pos[:y] || pos['y'],
+          }
+        end
+
+        # Determine the column bounds (start..end) for a given click/selection position
+        # by inspecting rendered geometry. Maintained for compatibility with
+        # consumers that still reason about legacy coordinate ranges.
+        def column_bounds_for(click_pos, rendered_lines)
+          pos = normalize_position(click_pos)
+          return nil unless pos
+
+          anchor_geometry = locate_geometry(rendered_lines, pos[:x], pos[:y])
+          return nil unless anchor_geometry
+
+          start_col = anchor_geometry.column_origin
+          {
+            start: start_col,
+            end: start_col + anchor_geometry.visible_width,
+          }
+        end
+
+        def column_overlaps?(line_start, line_end, bounds)
+          return false unless bounds
+
+          !(line_end < bounds[:start] || line_start > bounds[:end])
+        end
+
+        # Build an anchor from screen coordinates (0-based) using rendered geometry.
+        def anchor_from_point(point, rendered_lines, bias: :nearest)
+          pos = normalize_position(point)
+          return nil unless pos
+
+          geometry = locate_geometry(rendered_lines, pos[:x], pos[:y])
+          return nil unless geometry
+
+          cell_index = cell_index_for_geometry(geometry, pos[:x], bias)
+
+          Shoko::Core::Models::SelectionAnchor.new(
+            page_id: geometry.page_id,
+            column_id: geometry.column_id,
+            geometry_key: geometry.key,
+            line_offset: geometry.line_offset,
+            cell_index: cell_index,
+            row: geometry.row,
+            column_origin: geometry.column_origin
+          )
+        end
+
+        # Convenience helper for highlight logic: find the rendered line geometry
+        # that covers the provided terminal row.
+        def geometry_for_row(rendered_lines, row)
+          index = geometry_index_by_row(rendered_lines)
+          candidates = index[row]
+          candidates && candidates.first
+        end
+
+        protected
+
+        def required_dependencies
+          [] # No dependencies required for coordinate operations
+        end
+
+        private
+
+        def normalize_anchor(anchor, rendered_lines)
+          return nil unless anchor
+
+          selection_anchor = Shoko::Core::Models::SelectionAnchor.from(anchor)
+          return selection_anchor if selection_anchor&.geometry_key
+
+          return nil unless rendered_lines
+
+          anchor_from_point(anchor, rendered_lines)
+        end
+
+        def locate_geometry(rendered_lines, mouse_x, mouse_y)
+          row = mouse_y.to_i + 1
+          col = mouse_x.to_i + 1
+
+          candidates = geometry_index_by_row(rendered_lines)[row] || []
+          return nil if candidates.empty?
+
+          candidates.each do |geometry|
+            line_start = geometry.column_origin
+            line_end = line_start + geometry.visible_width
+
+            if col < line_start
+              return geometry if geometry.visible_width.zero?
+
+              next
+            end
+
+            return geometry if col <= line_end || geometry.visible_width.zero?
+          end
+
+          # No direct hit; fall back to the last geometry on the row for trailing whitespace selection.
+          candidates.last
+        end
+
+        def cell_index_for_geometry(geometry, mouse_x, bias)
+          cells = geometry.cells
+          return 0 if cells.empty?
+
+          target_col = mouse_x.to_i + 1
+          relative = target_col - geometry.column_origin
+          relative = 0 if relative.negative?
+
+          cells.each_with_index do |cell, index|
+            cell_start = cell.screen_x
+            cell_end = cell_start + cell.display_width
+
+            if relative < cell_start
+              return clamp_cell_index(index, cells.length, bias)
+            elsif relative < cell_end
+              return bias == :trailing ? [index + 1, cells.length].min : index
+            end
+          end
+
+          return cells.length if bias == :trailing
+
+          [cells.length - 1, 0].max
+        end
+
+        def clamp_cell_index(index, cell_count, bias)
+          case bias
+          when :trailing
+            [[index, cell_count].min, 0].max
+          when :leading
+            [[index, cell_count - 1].min, 0].max
+          else
+            index
+          end
+        end
+
+        def geometry_index_by_row(rendered_lines)
+          return {} unless rendered_lines
+
+          key = rendered_lines.object_id
+          if @geometry_index_key != key
+            @geometry_index_key = key
+            @geometry_index_by_row = build_geometry_index(rendered_lines)
+          end
+          @geometry_index_by_row || {}
+        end
+
+        def build_geometry_index(rendered_lines)
+          index = Hash.new { |h, k| h[k] = [] }
+          rendered_lines.each_value do |line_info|
+            geometry = line_info[:geometry]
+            next unless geometry
+
+            index[geometry.row] << geometry
+          end
+          index.each_value { |rows| rows.sort_by!(&:column_origin) }
+          index
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/layout_service.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative 'base_service'
+
+module Shoko
+  module Core
+    module Services
+      # Domain service for layout calculations with dependency injection.
+      # Migrated from legacy Services::LayoutService to follow DI pattern.
+      class LayoutService < BaseService
+        # Shared layout constants so pagination and rendering stay in sync
+        SPLIT_LEFT_MARGIN = 2
+        SPLIT_RIGHT_MARGIN = 2
+        SPLIT_COLUMN_GAP = 4
+        SPLIT_MIN_USABLE_WIDTH = 40
+        MIN_COLUMN_WIDTH = 20
+        CONTENT_TOP_PADDING = 2
+        CONTENT_BOTTOM_PADDING = 1
+        CONTENT_VERTICAL_PADDING = CONTENT_TOP_PADDING + CONTENT_BOTTOM_PADDING
+
+        # Calculate layout metrics for given dimensions and view mode
+        def calculate_metrics(width, height, view_mode)
+          col_width = view_mode == :split ? split_column_width(width) : single_column_width(width)
+          content_height = content_area_height(height)
+          [col_width, content_height]
+        end
+
+        # Adjust height for line spacing
+        def adjust_for_line_spacing(height, line_spacing)
+          return 1 if height <= 0
+
+          spacing = begin
+            line_spacing&.to_sym
+          rescue StandardError
+            nil
+          end
+
+          return [(height + 1) / 2, 1].max if spacing == :relaxed
+
+          multiplier = resolve_multiplier(spacing)
+          adjusted = (height * multiplier).floor
+          adjusted = height if multiplier >= 1.0 && adjusted < height
+          [adjusted, 1].max
+        end
+
+        # Calculate center start row for content
+        def calculate_center_start_row(content_height, lines_count, line_spacing)
+          actual_lines = line_spacing == :relaxed ? [(lines_count * 2) - 1, 0].max : lines_count
+          padding = [(content_height - actual_lines) / 2, 0].max
+          [3 + padding, 3].max
+        end
+
+        # Calculate optimal column width for text content
+        def calculate_optimal_column_width(available_width, _content_length)
+          # Use golden ratio for optimal reading width
+          optimal = (available_width * 0.618).to_i
+          optimal.clamp(40, 80) # Keep within readable bounds
+        end
+
+        # Calculate padding for centered content
+        def calculate_centered_padding(container_width, content_width)
+          [(container_width - content_width) / 2, 0].max
+        end
+
+        def content_area_height(height)
+          [height - CONTENT_VERTICAL_PADDING, 1].max
+        end
+
+        def split_column_width(width)
+          usable_width = [width - SPLIT_LEFT_MARGIN - SPLIT_RIGHT_MARGIN, SPLIT_MIN_USABLE_WIDTH].max
+          [(usable_width - SPLIT_COLUMN_GAP) / 2, MIN_COLUMN_WIDTH].max
+        end
+
+        def single_column_width(width)
+          (width * Core::Models::ReaderSettings::SINGLE_VIEW_WIDTH_PERCENT).to_i.clamp(30, 120)
+        end
+
+        def resolve_multiplier(line_spacing)
+          key = begin
+            line_spacing&.to_sym
+          rescue StandardError
+            nil
+          end
+          Shoko::Core::Models::ReaderSettings::LINE_SPACING_MULTIPLIERS.fetch(key, 1.0)
+        end
+
+        protected
+
+        def required_dependencies
+          [] # No dependencies required for layout calculations
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/absolute_change_applier.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative 'context_helpers'
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Applies absolute-mode changes and computes offsets from layout data.
+        class AbsoluteChangeApplier
+          CHANGE_PATHS = {
+            current_chapter: %i[reader current_chapter],
+            current_page: %i[reader current_page],
+            single_page: %i[reader single_page],
+            left_page: %i[reader left_page],
+            right_page: %i[reader right_page],
+          }.freeze
+
+          def initialize(state_updater:, absolute_layout:, image_snapper:, advance_callback:)
+            @state_updater = state_updater
+            @absolute_layout = absolute_layout
+            @image_snapper = image_snapper
+            @advance_callback = advance_callback
+          end
+
+          def apply(changes)
+            return if changes.nil? || changes.empty?
+
+            layout_state = @absolute_layout.build
+            return if handle_advance(changes[:advance_chapter], layout_state)
+
+            updates = build_updates(changes)
+            updates = apply_align_to_last(updates, changes, layout_state)
+            updates = @image_snapper.snap(updates, layout_state) if @image_snapper
+            @state_updater.apply(updates)
+          end
+
+          private
+
+          def handle_advance(advance, layout_state)
+            return false unless advance
+
+            current_chapter = ContextHelpers.current_chapter(layout_state.snapshot)
+            case advance
+            when :next
+              @advance_callback.call(current_chapter + 1)
+              true
+            when :prev
+              previous = current_chapter - 1
+              return true if previous.negative?
+
+              offset = @absolute_layout.max_offset_for(layout_state.snapshot, previous, layout_state.stride)
+              updates = { %i[reader current_chapter] => previous }
+              apply_offset(updates, layout_state, offset)
+              @state_updater.apply(updates)
+              true
+            else
+              false
+            end
+          end
+
+          def build_updates(changes)
+            updates = {}
+            CHANGE_PATHS.each do |key, path|
+              updates[path] = changes[key] if changes.key?(key)
+            end
+            updates
+          end
+
+          def apply_align_to_last(updates, changes, layout_state)
+            return updates unless changes[:align_to_last]
+
+            total = ContextHelpers.total_chapters(layout_state.snapshot)
+            total = 1 if total.to_i <= 0
+            last_chapter = total - 1
+            offset = @absolute_layout.max_offset_for(layout_state.snapshot, last_chapter, layout_state.stride)
+            updates[%i[reader current_chapter]] = last_chapter
+            apply_offset(updates, layout_state, offset)
+            updates
+          end
+
+          def apply_offset(updates, layout_state, offset)
+            updates[%i[reader current_page]] = offset
+            if layout_state.view_mode == :split
+              updates[%i[reader left_page]] = offset
+              updates[%i[reader right_page]] = offset + layout_state.stride
+            else
+              updates[%i[reader single_page]] = offset
+            end
+            updates
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoko/core/services/navigation/absolute_layout.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative 'context_helpers'
+
+module Shoko
+  module Core
+    module Services
+      module Navigation
+        # Computes absolute-layout metrics and enriches navigation contexts.
+        class AbsoluteLayout
+          # Snapshot of layout-derived values for absolute navigation.
+          LayoutState = Struct.new(:snapshot, :view_mode, :metrics, :stride, keyword_init: true)
+
+          def initialize(state_store:, layout_service:)
+            @state_store = state_store
+            @layout_service = layout_service
+          end
+
+          def build
+            snapshot = ContextHelpers.safe_snapshot(@state_store)
+            view_mode = ContextHelpers.current_view_mode(snapshot)
+            metrics = {
+              single: lines_for(snapshot, :single),
+              split: lines_for(snapshot, :split),
+            }
+            stride = view_mode == :split ? metrics[:split] : metrics[:single]
+            stride = metrics[:single] if stride.to_i <= 0
+            stride = 1 if stride.to_i <= 0
+            LayoutState.new(snapshot: snapshot, view_mode: view_mode, metrics: metrics, stride: stride)
+          end
+
+          def populate_context(ctx)
+            return ctx unless ctx.mode == :absolute
+
+            layout_state = build
+            ctx.lines_per_page = layout_state.metrics[:single]
+            ctx.column_lines_per_page = layout_state.metrics[:split]
+            ctx.max_page_in_chapter = page_count(layout_state.snapshot, ctx.current_chapter)
+            ctx.max_offset_in_chapter = max_offset_for(layout_state.snapshot, ctx.current_chapter, layout_state.stride)
+            ctx
+          end
+
+          def page_count(snapshot, chapter_index)
+            return 0 if chapter_index.nil?
+
+            snapshot.dig(:reader, :page_map)&.[](chapter_index) || 0
+          end
+
+          def max_offset_for(snapshot, chapter_index, stride)
+            return 0 if chapter_index.nil? || stride.to_i <= 0
+
+            pages = page_count(snapshot, chapter_index).to_i
+            return 0 if pages <= 1
+
+            (pages - 1) * stride
+          end
+
+          def column_width(snapshot, view_mode)
+            return fallback_width(snapshot) unless @layout_service
+
+            width = fallback_width(snapshot)
+            height = fallback_height(snapshot)
+            col_width, = @layout_service.calculate_metrics(width, height, view_mode)
+            col_width = width if col_width.to_i <= 0
+            col_width
+          rescue StandardError
+            fallback_width(snapshot)
+          end
+
+          private
+
+          def lines_for(snapshot, view_mode)
+            return fallback_lines(view_mode) unless @layout_service
+
+            width = fallback_width(snapshot)
+            height = fallback_height(snapshot)
+            _, content_height = @layout_service.calculate_metrics(width, height, view_mode)
+            line_spacing = snapshot.dig(:config, :line_spacing) || Shoko::Core::Models::ReaderSettings::DEFAULT_LINE_SPACING
+            lines = @layout_service.adjust_for_line_spacing(content_height, line_spacing)
+            lines = 1 if lines.to_i <= 0
+            lines
+          rescue StandardError
+            1
+          end
+
+          def fallback_width(snapshot)
+            snapshot.dig(:ui, :terminal_width) || 80
+          end
+
+          def fallback_height(snapshot)
+            snapshot.dig(:ui, :terminal_height) || 24
+          end
+
+          def fallback_lines(view_mode)
+            view_mode == :split ? 2 : 1
+          end
+        end
+      end
+    end
+  end
+end