module Scrivito
  module Cache
    module Chainable
      def read(key)
        transformed_key = transform_key(key)
        value = internal_read(transformed_key)
        if !value && next_store
          value = next_store.read(transformed_key)
          internal_write(transformed_key, value)
        end
        value
      end

      def write(key, value, expires_in: nil, persistent: true)
        transformed_key = transform_key(key)
        if persistent && forward_write?(key, value, expires_in)
          next_store.write(transformed_key, value, expires_in: expires_in)
        end

        internal_write(transformed_key, value, expires_in) if persistent || tentative?
      end

      def fetch(key, &block)
        read(key) || block.call.tap { |value| write(key, value) }
      end

      def clear
        raise NotImplementedError
      end

      def clear_all
        clear
        next_store.clear if next_store
      end

      private

      def tentative?
        raise NotImplementedError
      end

      def next_store
        raise NotImplementedError
      end

      def internal_read(key)
        raise NotImplementedError
      end

      def internal_write(key, value, expires_in)
        raise NotImplementedError
      end

      def transform_key(key)
        key
      end

      def forward_write?(key, value, expires_in)
        next_store.present?
      end
    end
  end
end