package com.bradmcevoy.http.http11;
   
   import com.bradmcevoy.http.*;
   import com.bradmcevoy.http.Request.Method;
   import com.bradmcevoy.http.exceptions.BadRequestException;
   import com.bradmcevoy.http.exceptions.ConflictException;
   import com.bradmcevoy.http.exceptions.NotAuthorizedException;
   import java.util.Date;
   import java.util.Map;
  
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  public class GetHandler implements ExistingEntityHandler {
  
      private static final Logger log = LoggerFactory.getLogger( GetHandler.class );
      private final Http11ResponseHandler responseHandler;
      private final HandlerHelper handlerHelper;
      private final ResourceHandlerHelper resourceHandlerHelper;
  
      public GetHandler( Http11ResponseHandler responseHandler, HandlerHelper handlerHelper ) {
          this.responseHandler = responseHandler;
          this.handlerHelper = handlerHelper;
          this.resourceHandlerHelper = new ResourceHandlerHelper( handlerHelper, responseHandler );
      }
  
      @Override
      public void process( HttpManager manager, Request request, Response response ) throws NotAuthorizedException, ConflictException, BadRequestException {
          log.debug( "process" );
          this.resourceHandlerHelper.process( manager, request, response, this );
      }
  
      @Override
      public void processResource( HttpManager manager, Request request, Response response, Resource r ) throws NotAuthorizedException, ConflictException, BadRequestException {
          manager.onGet( request, response, r, request.getParams() );
          resourceHandlerHelper.processResource( manager, request, response, r, this, true, request.getParams(), null );
      }
  
      public void processExistingResource( HttpManager manager, Request request, Response response, Resource resource ) throws NotAuthorizedException, BadRequestException, ConflictException {
          if( log.isTraceEnabled() ) {
              log.trace( "process: " + request.getAbsolutePath() );
          }
          GetableResource r = (GetableResource) resource;
          if( checkConditional( r, request ) ) {
              if( log.isTraceEnabled() ) {
                  log.trace( "respond not modified with: " + responseHandler.getClass().getCanonicalName() );
              }
              responseHandler.respondNotModified( r, response, request );
              return;
          }
  
          sendContent( manager, request, response, r, request.getParams() );
      }
  
      public Range getRange( Request requestInfo ) {
          // Thanks Igor!
          String rangeHeader = requestInfo.getRangeHeader();
          if( rangeHeader == null ) return null;
          final Matcher matcher = Pattern.compile( "\\s*bytes\\s*=\\s*(\\d+)-(\\d+)" ).matcher( rangeHeader );
          if( matcher.matches() ) {
              return new Range( Long.parseLong( matcher.group( 1 ) ), Long.parseLong( matcher.group( 2 ) ) );
          }
          return null;
      }
  
      /** Return true if the resource has not been modified
       */
      private boolean checkConditional( GetableResource resource, Request request ) {
          // If maxAgeSeconds is null then we do not cache
          if( resource.getMaxAgeSeconds( request.getAuthorization() ) == null ) {
              log.trace( "resource has null max age, so not modified response is disabled" );
              return false;
          }
          if( checkIfMatch( resource, request ) ) {
              return true;
          }
          if( checkIfModifiedSince( resource, request ) ) {
              log.trace( "is not modified since" );
              return true;
          }
          if( checkIfNoneMatch( resource, request ) ) {
              return true;
          }
          return false;
      }
  
      private boolean checkIfMatch( GetableResource handler, Request requestInfo ) {
          return false;   // TODO: not implemented
      }
  
      /**
       *
       * @param resource
       * @param requestInfo
       * @return - true if the resource has NOT been modified since that date in the request
       */
      private boolean checkIfModifiedSince( GetableResource resource, Request requestInfo ) {
         log.trace( "checkIfModifiedSince" );
         Long maxAgeSecs = resource.getMaxAgeSeconds( requestInfo.getAuthorization() );
 
         if( maxAgeSecs == null ) {
             log.trace( "checkIfModifiedSince: null max age" );
             return false; // if null, always generate a fresh response
         } else {
             log.trace( "checkIfModifiedSince with maxAge" );
             Date dtRequest = requestInfo.getIfModifiedHeader();
             if( dtRequest == null ) {
                 log.trace( " no modified date header" );
                 return false;
             }
             long timeNow = System.currentTimeMillis();
             long timeRequest = dtRequest.getTime() + 1000; // allow for rounding to nearest second
             long timeElapsed = timeNow - timeRequest;
             if( timeElapsed > maxAgeSecs ) {
                 log.trace( "its been longer then the max age period, so generate fresh response" );
                 return false;
             } else {
                 Date dtCurrent = resource.getModifiedDate();
                 if( dtCurrent == null ) {
                     if( log.isTraceEnabled() ) {
                         log.trace( "no modified date on resource: " + resource.getClass().getCanonicalName() );
                     }
                     return true;
                 }
 
                 long timeActual = dtCurrent.getTime();
                 boolean unchangedSince = ( timeRequest >= timeActual );
                 if( log.isTraceEnabled() ) {
                     log.trace( "times as long: " + dtCurrent.getTime() + " - " + dtRequest.getTime() );
                     log.trace( "checkModifiedSince: actual: " + dtCurrent + " - request:" + dtRequest + " = " + unchangedSince + " (true indicates no change)" );
                 }
 
                 // If the modified time requested is greater or equal then the actual modified time, do not generate response
                 return unchangedSince;
             }
         }
     }
 
     private boolean checkIfNoneMatch( GetableResource handler, Request requestInfo ) {
         return false;   // TODO: not implemented
     }
 
     @Override
     public String[] getMethods() {
         return new String[]{Request.Method.GET.code, Request.Method.HEAD.code};
     }
 
     @Override
     public boolean isCompatible( Resource handler ) {
         return ( handler instanceof GetableResource );
     }
 
     private void sendContent( HttpManager manager, Request request, Response response, GetableResource resource, Map<String, String> params ) throws NotAuthorizedException, BadRequestException {
         try {
             if( request.getMethod().equals( Method.HEAD ) ) {
                 responseHandler.respondHead( resource, response, request );
             } else {
                 Range range = getRange( request );
                 if( range != null ) {
                     log.trace( "partial" );
                     responseHandler.respondPartialContent( resource, response, request, params, range );
                 } else {
                     if( log.isTraceEnabled() ) {
                         log.trace( "normal content: " + responseHandler.getClass().getCanonicalName() );
                     }
                     responseHandler.respondContent( resource, response, request, params );
                 }
             }
         } catch( NotAuthorizedException notAuthorizedException ) {
             throw notAuthorizedException;
         } catch( BadRequestException badRequestException ) {
             throw badRequestException;
         } catch( Throwable e ) {
             log.error( "Exception sending content for:" + request.getAbsolutePath() + " of resource type: " + resource.getClass().getCanonicalName() );
             throw new RuntimeException( e );
         }
     }
 }