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, options = {})
        transformed_key = transform_key(key)
        next_store.write(transformed_key, value, options) if next_store
        internal_write(transformed_key, value, options)
      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 next_store
        raise NotImplementedError
      end

      def internal_read(key)
        raise NotImplementedError
      end

      def internal_write(key, value, options = {})
        raise NotImplementedError
      end

      def transform_key(key)
        key
      end
    end
  end
end