package de.juplo.httpresources;
   
   import org.springframework.http.HttpHeaders;
   import org.springframework.util.MimeType;
   
   import java.io.*;
   import java.net.URI;
   import java.net.URL;
   import java.time.Clock;
  import java.util.Objects;
  
  
  public class HttpResource implements org.springframework.web.servlet.resource.HttpResource
  {
    final HttpResources resources;
    final HttpResourceFetcher fetcher;
    final Clock clock;
    final URI uri;
  
    HttpData data;
    boolean modified;
  
    HttpResource(
        HttpResources resources,
        HttpResourceFetcher fetcher,
        Clock clock,
        URI uri)
    {
      this(resources, fetcher, clock, uri, HttpData.NOT_FETCHED);
    }
  
    HttpResource(
          HttpResources resources,
          HttpResourceFetcher fetcher,
          Clock clock,
          URI uri,
          HttpData data)
      {
      this.resources = resources;
      this.fetcher = fetcher;
      this.clock = clock;
      this.uri = uri;
      this.data = data;
    }
  
  
    synchronized public long expires()
    {
      return data.expires;
    }
  
    synchronized public boolean isExpired()
    {
      return data.expires < clock.millis();
    }
  
    @Override
    synchronized public boolean exists()
    {
      if (isExpired())
        fetch();
      return data.content != null;
    }
  
    @Override
    synchronized public boolean isReadable()
    {
      return exists();
    }
  
    @Override
    public boolean isOpen()
    {
      return false;
    }
  
    @Override
    public URL getURL() throws IOException
    {
      return uri.toURL();
    }
  
    @Override
    public URI getURI()
    {
      return uri;
    }
  
    @Override
    public File getFile() throws IOException
    {
      throw new FileNotFoundException("The resource " + getDescription() + " cannot be retrived as file");
    }
  
    @Override
    synchronized public long contentLength() throws IOException
    {
      if (!fetched())
        fetch();
 
     if (data.content == null)
       throw new FileNotFoundException("The resource " + getDescription() + " cannot be retrived");
 
     return data.content.length;
   }
 
   synchronized public MimeType contentType()
   {
     return data.headers.getContentType();
   }
 
   @Override
   synchronized public long lastModified() throws IOException
   {
     if (!fetched())
       fetch();
 
     if (data.content == null)
       throw new FileNotFoundException("The resource " + getDescription() + " cannot be retrived");
 
     return data.lastModified;
   }
 
   synchronized public String eTag()
   {
     return data.eTag;
   }
 
   @Override
   public HttpResource createRelative(String relativePath) throws IOException
   {
     try
     {
       return createRelative(HttpResources.convert(relativePath));
     }
     catch (IllegalArgumentException e)
     {
       throw new IOException("Invalid relative path: " + relativePath, e);
     }
   }
 
   public HttpResource createRelative(URI relative) throws IOException
   {
     return resources.getResource(HttpResources.resolve(relative, uri));
   }
 
   @Override
   public String getFilename()
   {
     return uri.getPath();
   }
 
   @Override
   public String getDescription()
   {
     return "HTTP [" + this.uri + "]";
   }
 
   @Override
   synchronized public InputStream getInputStream() throws IOException
   {
     if (!fetched())
     {
       fetch();
     }
     else
     {
       isModified();
     }
 
     // Clear the modified-flag
     modified = false;
 
     if (data.content == null)
       throw new FileNotFoundException("The resource " + getDescription() + " cannot be retrived as file");
 
     return new ByteArrayInputStream(data.content);
   }
 
   synchronized public boolean isModified()
   {
     if (modified)
     {
       return true;
     }
 
     if (!isExpired())
     {
       return false;
     }
 
     return fetch();
   }
 
   /**
    * Checks, if the remote resource was already fetched.
    *
    * @return {@code true}, if the resource was already fetched, otherwise
    * {@code false}
    */
   synchronized public boolean fetched()
   {
     return data.expires != Long.MIN_VALUE;
   }
 
   /**
    * Fetches the remote resource and reports, if it was modified.
    * <p>
    * This method fetches the remote resource, if was not already fetched.
    * If the resource was already fetched, it revalidates it, if necessary.
    *
    * @return {@code true}, if the resource has changed or was fetched for
    * the first time, otherwise {@code false}
    */
   synchronized public boolean fetch()
   {
     HttpData result = fetcher.fetch(uri, data);
 
     // Flag the resource as modified, if the data has changed
     // Otherwise, keep the old state of the modified-flag.
     modified = !data.equals(result);
 
     data = result;
 
     return modified;
   }
 
   @Override
   synchronized public HttpHeaders getResponseHeaders()
   {
     return data.headers;
   }
 
 
   @Override
   public int hashCode()
   {
     return uri.hashCode();
   }
 
   @Override
   public boolean equals(Object o)
   {
     if (o == null)
       return false;
     if (o == this)
       return true;
     if (!(o instanceof HttpResource))
       return false;
     return Objects.equals(uri, ((HttpResource) o).uri);
   }
 
   @Override
   public String toString()
   {
     return getDescription();
   }
 }