/****************************************************************
    * Licensed to the Apache Software Foundation (ASF) under one   *
    * or more contributor license agreements.  See the NOTICE file *
    * distributed with this work for additional information        *
    * regarding copyright ownership.  The ASF licenses this file   *
    * to you under the Apache License, Version 2.0 (the            *
    * "License"); you may not use this file except in compliance   *
    * with the License.  You may obtain a copy of the License at   *
    *                                                              *
   *   http://www.apache.org/licenses/LICENSE-2.0                 *
   *                                                              *
   * Unless required by applicable law or agreed to in writing,   *
   * software distributed under the License is distributed on an  *
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY       *
   * KIND, either express or implied.  See the License for the    *
   * specific language governing permissions and limitations      *
   * under the License.                                           *
   ****************************************************************/
  
  
  package org.apache.james.jspf.core;
  
  /**
   * This Class is used to convert all macros which can used in SPF-Records to the
   * right values!
   * 
   */
  
  import org.apache.james.jspf.core.exceptions.NeutralException;
  import org.apache.james.jspf.core.exceptions.NoneException;
  import org.apache.james.jspf.core.exceptions.PermErrorException;
  import org.apache.james.jspf.core.exceptions.TempErrorException;
  import org.apache.james.jspf.core.exceptions.TimeoutException;
  
  import java.io.UnsupportedEncodingException;
  import java.net.URLEncoder;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  public class MacroExpand {
  
      private Pattern domainSpecPattern;
  
      private Pattern macroStringPattern;
  
      private Pattern macroLettersPattern;
  
      private Pattern macroLettersExpPattern;
  
      private Pattern cellPattern;
  
      private Logger log;
  
      private DNSService dnsProbe;
  
      public static final boolean EXPLANATION = true;
      
      public static final boolean DOMAIN = false;
      
      public static class RequireClientDomainException extends Exception {
  
          private static final long serialVersionUID = 3834282981657676530L;
          
      }
  
      /**
       * Construct MacroExpand
       * 
       * @param logger the logget to use
       * @param dnsProbe the dns service to use
       */
      public MacroExpand(Logger logger, DNSService dnsProbe) {
          // This matches 2 groups
          domainSpecPattern = Pattern.compile(SPFTermsRegexps.DOMAIN_SPEC_REGEX_R);
          // The real pattern replacer
          macroStringPattern = Pattern.compile(SPFTermsRegexps.MACRO_STRING_REGEX_TOKEN);
          // The macro letters pattern
          macroLettersExpPattern = Pattern.compile(SPFTermsRegexps.MACRO_LETTER_PATTERN_EXP);
          macroLettersPattern = Pattern.compile(SPFTermsRegexps.MACRO_LETTER_PATTERN);
          log = logger;
          this.dnsProbe = dnsProbe;
      }
      
  
      private static final class AResponseListener implements
              SPFCheckerDNSResponseListener {
          
          /**
           * @see org.apache.james.jspf.core.SPFCheckerDNSResponseListener#onDNSResponse(org.apache.james.jspf.core.DNSResponse, org.apache.james.jspf.core.SPFSession)
           */
          public DNSLookupContinuation onDNSResponse(DNSResponse response, SPFSession session)
                  throws PermErrorException, NoneException, TempErrorException,
                  NeutralException {
              // just return the default "unknown" if we cannot find anything
              // later
              session.setClientDomain("unknown");
             try {
                 List records = response.getResponse();
                 if (records != null && records.size() > 0) {
                     Iterator i = records.iterator();
                     while (i.hasNext()) {
                         String next = (String) i.next();
                         if (IPAddr.getAddress(session.getIpAddress())
                                 .toString().equals(
                                         IPAddr.getAddress(next).toString())) {
                             session
                                     .setClientDomain((String) session
                                             .getAttribute(ATTRIBUTE_MACRO_EXPAND_CHECKED_RECORD));
                             break;
                         }
                     }
                 }
             } catch (TimeoutException e) {
                 // just return the default "unknown".
             } catch (PermErrorException e) {
                 // just return the default "unknown".
             }
             return null;
         }
     }
 
     private static final class PTRResponseListener implements
             SPFCheckerDNSResponseListener {
 
         /**
          * @see org.apache.james.jspf.core.SPFCheckerDNSResponseListener#onDNSResponse(org.apache.james.jspf.core.DNSResponse, org.apache.james.jspf.core.SPFSession)
          */
         public DNSLookupContinuation onDNSResponse(DNSResponse response, SPFSession session)
                 throws PermErrorException, NoneException, TempErrorException,
                 NeutralException {
 
             try {
                 boolean ip6 = IPAddr.isIPV6(session.getIpAddress());
                 List records = response.getResponse();
 
                 if (records != null && records.size() > 0) {
                     String record = (String) records.get(0);
                     session.setAttribute(ATTRIBUTE_MACRO_EXPAND_CHECKED_RECORD,
                             record);
 
                     return new DNSLookupContinuation(new DNSRequest(record,
                             ip6 ? DNSRequest.AAAA : DNSRequest.A), 
                             new AResponseListener());
 
                 }
             } catch (TimeoutException e) {
                 // just return the default "unknown".
                 session.setClientDomain("unknown");
             }
             return null;
 
         }
     }
 
     private static final String ATTRIBUTE_MACRO_EXPAND_CHECKED_RECORD = "MacroExpand.checkedRecord";
 
     public DNSLookupContinuation checkExpand(String input, SPFSession session, boolean isExplanation) throws PermErrorException, NoneException {
         if (input != null) {
             String host = this.expand(input, session, isExplanation);
             if (host == null) {
 
                 return new DNSLookupContinuation(new DNSRequest(IPAddr
                         .getAddress(session.getIpAddress()).getReverseIP(),
                         DNSRequest.PTR), new PTRResponseListener());
             }
         }
         return null;
     }
     
     public String expand(String input, MacroData macroData, boolean isExplanation) throws PermErrorException {
         try {
             if (isExplanation) {
                 return expandExplanation(input, macroData);
             } else {
                 return expandDomain(input, macroData);
             }
         } catch (RequireClientDomainException e) {
             return null;
         }
     }
 
     /**
      * This method expand the given a explanation
      * 
      * @param input
      *            The explanation which should be expanded
      * @return expanded The expanded explanation
      * @throws PermErrorException
      *             Get thrown if invalid macros are used
      * @throws RequireClientDomain 
      */
     private String expandExplanation(String input, MacroData macroData) throws PermErrorException, RequireClientDomainException {
 
         log.debug("Start do expand explanation: " + input);
 
         String[] parts = input.split(" ");
         StringBuffer res = new StringBuffer();
         for (int i = 0; i < parts.length; i++) {
             if (i > 0) res.append(" ");
             res.append(expandMacroString(parts[i], macroData, true));
         }
         log.debug("Done expand explanation: " + res);
         
         return res.toString();
     }
 
     /**
      * This method expand the given domain. So all known macros get replaced
      * 
      * @param input
      *            The domain which should be expand
      * @return expanded The domain with replaced macros
      * @throws PermErrorException
      *             This get thrown if invalid macros are used
      * @throws RequireClientDomain 
      */
     private String expandDomain(String input, MacroData macroData) throws PermErrorException, RequireClientDomainException {
 
         log.debug("Start expand domain: " + input);
 
         Matcher inputMatcher = domainSpecPattern.matcher(input);
         if (!inputMatcher.matches() || inputMatcher.groupCount() != 2) {
             throw new PermErrorException("Invalid DomainSpec: "+input);
         }
 
         StringBuffer res = new StringBuffer();
         if (inputMatcher.group(1) != null && inputMatcher.group(1).length() > 0) {
             res.append(expandMacroString(inputMatcher.group(1), macroData, false));
         }
         if (inputMatcher.group(2) != null && inputMatcher.group(2).length() > 0) {
             if (inputMatcher.group(2).startsWith(".")) {
                 res.append(inputMatcher.group(2));
             } else {
                 res.append(expandMacroString(inputMatcher.group(2), macroData, false));
             }
         }
         
         String domainName = expandMacroString(input, macroData, false);
         // reduce to less than 255 characters, deleting subdomains from left
         int split = 0;
         while (domainName.length() > 255 && split > -1) {
             split = domainName.indexOf(".");
             domainName = domainName.substring(split + 1);
         }
 
         log.debug("Domain expanded: " + domainName);
         
         return domainName;
     }
 
     /**
      * Expand the given String
      * 
      * @param input
      *            The inputString which should get expanded
      * @return expanded The expanded given String
      * @throws PermErrorException
      *             This get thrown if invalid macros are used
      * @throws RequireClientDomain 
      */
     private String expandMacroString(String input, MacroData macroData, boolean isExplanation) throws PermErrorException, RequireClientDomainException {
 
         StringBuffer decodedValue = new StringBuffer();
         Matcher inputMatcher = macroStringPattern.matcher(input);
         String macroCell;
         int pos = 0;
 
         while (inputMatcher.find()) {
             String match2 = inputMatcher.group();
             if (pos != inputMatcher.start()) {
                 throw new PermErrorException("Middle part does not match: "+input.substring(0,pos)+">>"+input.substring(pos, inputMatcher.start())+"<<"+input.substring(inputMatcher.start())+" ["+input+"]");
             }
             if (match2.length() > 0) {
                 if (match2.startsWith("%{")) {
                     macroCell = input.substring(inputMatcher.start() + 2, inputMatcher
                             .end() - 1);
                     inputMatcher
                             .appendReplacement(decodedValue, escapeForMatcher(replaceCell(macroCell, macroData, isExplanation)));
                 } else if (match2.length() == 2 && match2.startsWith("%")) {
                     // handle the % escaping
                     /*
                      * From RFC4408:
                      * 
                      * A literal "%" is expressed by "%%".
                      *   "%_" expands to a single " " space.
                      *   "%-" expands to a URL-encoded space, viz., "%20".
                      */
                     if ("%_".equals(match2)) {
                         inputMatcher.appendReplacement(decodedValue, " ");
                     } else if ("%-".equals(match2)) {
                         inputMatcher.appendReplacement(decodedValue, "%20");
                     } else {
                         inputMatcher.appendReplacement(decodedValue, escapeForMatcher(match2.substring(1)));
                     }
                 }
             }
             
             pos = inputMatcher.end();
         }
         
         if (input.length() != pos) {
             throw new PermErrorException("End part does not match: "+input.substring(pos));
         }
         
         inputMatcher.appendTail(decodedValue);
 
         return decodedValue.toString();
     }
 
     /**
      * Replace the macros in given String
      * 
      * @param replaceValue
      *            The String in which known macros should get replaced
      * @return returnData The String with replaced macros
      * @throws PermErrorException
      *             Get thrown if an error in processing happen
      * @throws RequireClientDomain 
      */
     private String replaceCell(String replaceValue, MacroData macroData, boolean isExplanation) throws PermErrorException, RequireClientDomainException {
 
         String variable = "";
         String domainNumber = "";
         boolean isReversed = false;
         String delimeters = ".";
 
         
         // Get only command character so that 'r' command and 'r' modifier don't
         // clash
         String commandCharacter = replaceValue.substring(0, 1);
         Matcher cellMatcher;
         // Find command
         if (isExplanation) {
             cellMatcher = macroLettersExpPattern.matcher(commandCharacter);
         } else {
             cellMatcher = macroLettersPattern.matcher(commandCharacter);
         }
         if (cellMatcher.find()) {
             if (cellMatcher.group().toUpperCase().equals(cellMatcher.group())) {
                 variable = encodeURL(matchMacro(cellMatcher.group(), macroData));
             } else {
                 variable = matchMacro(cellMatcher.group(), macroData);
             }
             // Remove Macro code so that r macro code does not clash with r the
             // reverse modifier
             replaceValue = replaceValue.substring(1);
         } else {
             throw new PermErrorException("MacroLetter not found: "+replaceValue);
         }
 
         // Find number of domains to use
         cellPattern = Pattern.compile("\\d+");
         cellMatcher = cellPattern.matcher(replaceValue);
         while (cellMatcher.find()) {
             domainNumber = cellMatcher.group();
             if (Integer.parseInt(domainNumber) == 0) {
                 throw new PermErrorException(
                         "Digit transformer must be non-zero");
             }
         }
         // find if reversed
         cellPattern = Pattern.compile("r");
         cellMatcher = cellPattern.matcher(replaceValue);
         while (cellMatcher.find()) {
             isReversed = true;
         }
 
         // find delimeters
         cellPattern = Pattern.compile("[\\.\\-\\+\\,\\/\\_\\=]+");
         cellMatcher = cellPattern.matcher(replaceValue);
         while (cellMatcher.find()) {
             delimeters = cellMatcher.group();
         }
 
         // Reverse domains as necessary
         ArrayList data = split(variable, delimeters);
         if (isReversed) {
             data = reverse(data);
         }
 
         // Truncate domain name to number of sub sections
         String returnData;
         if (!domainNumber.equals("")) {
             returnData = subset(data, Integer.parseInt(domainNumber));
         } else {
             returnData = subset(data);
         }
 
         return returnData;
 
     }
 
     /**
      * Get the value for the given macro like descripted in the RFC
      * 
      * @param macro
      *            The macro we want to get the value for
      * @return rValue The value for the given macro
      * @throws PermErrorException
      *             Get thrown if the given variable is an unknown macro
      * @throws RequireClientDomain requireClientDomain if the client domain is needed
      *             and not yet resolved.
      */
     private String matchMacro(String macro, MacroData macroData) throws PermErrorException, RequireClientDomainException {
 
         String rValue = null;
 
         String variable = macro.toLowerCase();
         if (variable.equalsIgnoreCase("i")) {
             rValue = macroData.getMacroIpAddress();
         } else if (variable.equalsIgnoreCase("s")) {
             rValue = macroData.getMailFrom();
         } else if (variable.equalsIgnoreCase("h")) {
             rValue = macroData.getHostName();
         } else if (variable.equalsIgnoreCase("l")) {
             rValue = macroData.getCurrentSenderPart();
         } else if (variable.equalsIgnoreCase("d")) {
             rValue = macroData.getCurrentDomain();
         } else if (variable.equalsIgnoreCase("v")) {
             rValue = macroData.getInAddress();
         } else if (variable.equalsIgnoreCase("t")) {
             rValue = Long.toString(macroData.getTimeStamp());
         } else if (variable.equalsIgnoreCase("c")) {
             rValue = macroData.getReadableIP();
         } else if (variable.equalsIgnoreCase("p")) {
             rValue = macroData.getClientDomain();
             if (rValue == null) {
                 throw new RequireClientDomainException();
             }
         } else if (variable.equalsIgnoreCase("o")) {
             rValue = macroData.getSenderDomain();
         } else if (variable.equalsIgnoreCase("r")) {
             rValue = macroData.getReceivingDomain();
             if (rValue == null) {
                 rValue = "unknown";
                 List dNames = dnsProbe.getLocalDomainNames();
 
                 for (int i = 0; i < dNames.size(); i++) {
                     // check if the domainname is a FQDN
                     if (SPF1Utils.checkFQDN(dNames.get(i).toString())) {
                         rValue = dNames.get(i).toString();
                         if (macroData instanceof SPFSession) {
                             ((SPFSession) macroData).setReceivingDomain(rValue);
                         }
                         break;
                     }
                 }
             }
         }
 
         if (rValue == null) {
             throw new PermErrorException("Unknown command : " + variable);
 
         } else {
             log.debug("Used macro: " + macro + " replaced with: " + rValue);
 
             return rValue;
         }
     }
 
     /**
      * Create an ArrayList by the given String. The String get splitted by given
      * delimeters and one entry in the Array will be made for each splited
      * String
      * 
      * @param data
      *            The String we want to put in the Array
      * @param delimeters
      *            The delimeter we want to use to split the String
      * @return ArrayList which contains the String parts
      */
     private ArrayList split(String data, String delimeters) {
 
         String currentChar;
         StringBuffer element = new StringBuffer();
         ArrayList splitParts = new ArrayList();
 
         for (int i = 0; i < data.length(); i++) {
             currentChar = data.substring(i, i + 1);
             if (delimeters.indexOf(currentChar) > -1) {
                 splitParts.add(element.toString());
                 element.setLength(0);
             } else {
                 element.append(currentChar);
             }
         }
         splitParts.add(element.toString());
         return splitParts;
     }
 
     /**
      * Reverse an ArrayList
      * 
      * @param data
      *            The ArrayList we want to get reversed
      * @return reversed The reversed given ArrayList
      */
     private ArrayList reverse(ArrayList data) {
 
         ArrayList reversed = new ArrayList();
         for (int i = 0; i < data.size(); i++) {
             reversed.add(0, data.get(i));
         }
         return reversed;
     }
 
     /**
      * @see #subset(ArrayList, int)
      */
     private String subset(ArrayList data) {
         return subset(data, data.size());
     }
 
     /**
      * Convert a ArrayList to a String which holds the entries seperated by dots
      * 
      * @param data The ArrayList which should be converted
      * @param length The ArrayLength
      * @return A String which holds all entries seperated by dots
      */
     private String subset(ArrayList data, int length) {
 
         StringBuffer buildString = new StringBuffer();
         if (data.size() < length) {
             length = data.size();
         }
         int start = data.size() - length;
         for (int i = start; i < data.size(); i++) {
             if (buildString.length() > 0) {
                 buildString.append(".");
             }
             buildString.append(data.get(i));
         }
         return buildString.toString();
 
     }
 
     /**
      * Encode the given URL to UTF-8
      * 
      * @param data
      *            url to encode
      * @return encoded URL
      */
     private String encodeURL(String data) {
 
         try {
             // TODO URLEncoder method is not RFC2396 compatible, known
             // difference
             // is Space character gets converted to "+" rather than "%20"
             // Is there anything else which is not correct with URLEncoder?
             // Couldn't find a RFC2396 encoder
             data = URLEncoder.encode(data, "UTF-8");
         } catch (UnsupportedEncodingException e) {
             // This shouldn't happen ignore it!
         }
 
         // workaround for the above descripted problem
         return data.replaceAll("\\+", "%20");
 
     }
     
     /**
      * Because Dollar signs may be treated as references to captured subsequences in method Matcher.appendReplacement
      * its necessary to escape Dollar signs because its allowed in the local-part of an emailaddress.
      * 
      * See JSPF-71 for the bugreport
      * 
      * @param raw
      * @return escaped string
      */
     private String escapeForMatcher(String raw) {
         StringBuffer sb = new StringBuffer();
 
         for (int i = 0; i < raw.length(); i++) {
             char c = raw.charAt(i);
             if (c == '$' || c == '\\') {
                 sb.append('\\');
             }
             sb.append(c);
         }
         return sb.toString();
     }
 
 }