package ru.bitel.bgbilling.modules.inet.dyn.device.manad;

import java.io.PrintWriter;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;

import ru.bitel.bgbilling.modules.inet.access.sa.ServiceActivator;
import ru.bitel.bgbilling.modules.inet.access.sa.ServiceActivatorEvent;
import ru.bitel.bgbilling.modules.inet.api.common.bean.InetConnection;
import ru.bitel.bgbilling.modules.inet.api.common.bean.InetDevice;
import ru.bitel.bgbilling.modules.inet.api.common.bean.InetDeviceType;
import ru.bitel.bgbilling.modules.inet.api.common.bean.InetServ;
import ru.bitel.bgbilling.modules.inet.dyn.device.terminal.AbstractTerminalServiceActivator;
import ru.bitel.bgbilling.server.util.Setup;
import ru.bitel.common.ParameterMap;
import ru.bitel.common.Utils;

public class FreeBSDServiceActivator extends AbstractTerminalServiceActivator
   
    implements ServiceActivator
{
   private static Logger logger = Logger.getLogger( ManadServiceActivator.class );
   
   private Set<Integer> ipResourceIds;
   private InetDevice inetDevice;
   
   protected static final Pattern paramMultiPattern = Pattern.compile(    "\\$paramMulti\\((.*)\\)" );
   
   private Socket socket;
   PrintWriter out;
   @Override
    public Object init( Setup setup, int moduleId, InetDevice device, InetDeviceType deviceType, ParameterMap config )
        throws Exception
    {
       super.init( setup, moduleId, device, deviceType, config );
      this.inetDevice = device;
      this.ipResourceIds = Utils.toIntegerSet( config.get( "sa.ipResourceIds", null ) );
      List<InetSocketAddress> hosts = device.getHosts();
       return null;
    }   
   
   @Override
    public Object connect()
        throws Exception
    {
      List<InetSocketAddress> hosts = inetDevice.getHosts();
      
      InetSocketAddress socketAddress = hosts.get( 0 );
      String host = socketAddress.getAddress().getHostAddress();
      int port = socketAddress.getPort();
       
      socket = new Socket( host, port );
      out = new PrintWriter( socket.getOutputStream(), true );
      
      logger.info( "Connected" );
      
      return super.connect();
    }

   @Override
    public Object disconnect()
        throws Exception
    {
      super.disconnect();
      out.close();
      socket.close();
      
      logger.info( "Disconnected" );
      return null;
    }

   

   @Override
    protected void executeCommand( String command )
        throws Exception
    {
      logger.info( "execute: " + command );
      out.println( command );
    }

   @Override
   protected Object executeCommands( ServiceActivatorEvent e, InetServ serv, InetConnection connection, Set<Integer> options, String[] commands )
      throws Exception
   {
      InetServ inetServ = e.getNewInetServ()!=null? e.getNewInetServ() : e.getOldInetServ();

      if ( this.ipResourceIds.size()>0 && !this.ipResourceIds.contains( inetServ.getIpResourceId() ) )
      {
      return null;
      }
      if( commands == null )
      {
         return null;
      }

      if( this.workingOptions != null )
      {
         options = new HashSet<Integer>( options );
         options.retainAll( this.workingOptions );
      }
      
      
      List<InetServ> childrens = serv.getChildren();
      
      List<InetServ> servs = new ArrayList<>();
      //если потомков у сервиса нет, то мы только его обрабатываем

            
      String fullCommand = generateRule( commands, serv, servs, e, connection, options );      
      fullCommand = fullCommand.replaceAll( "\\\\t", "\t" );
      fullCommand = fullCommand.replaceAll( "\n", "|" );
      logger.debug( "fullCommand=" + fullCommand );
      
      if( Utils.notBlankString( fullCommand ) )
      {
         executeCommand( fullCommand.trim() );
      }
   
      return null;
   }
   
   
   public final String generateRule( String[] commands, InetServ mainServ, List<InetServ> servs, ServiceActivatorEvent e, InetConnection connection, Set<Integer> options )
   {
      String commandStr = "";
      for( String command : commands )
      {
         commandStr +=  command + "\n";
      }
      
      //Если указан макрос multiParam, учитываем его
      commandStr = getParamMulti( commandStr );
      
      StringBuffer resultBuf = null;
      resultBuf = new StringBuffer ();
      String loopPattern = "(<LOOP>.*?</LOOP>)?(.*?)<LOOP>(.*?)</LOOP>";
      Pattern pattern = Pattern.compile( loopPattern, Pattern.DOTALL );
      Matcher m = pattern.matcher( commandStr );
      boolean find = false;

      while( m.find() )
      {
         find = true;
         
         String block = m.group( 3 ).trim();
         block = processBlock( block, servs, e, connection, options ).toString();
         
         String beforeLoop =  m.group( 2 );
         beforeLoop = this.macrosFormat.format( beforeLoop, e, mainServ, connection, options );
         
         resultBuf.append( beforeLoop.trim() + "\n" );
         resultBuf.append( block.trim() );            
      }
      
      if (find)
      {
         //хвост(ищем жадным алгоритмом) или если вообще нет ни одного цикла
         loopPattern = "(?:<LOOP>(?:.*)</LOOP>)(.*)\\z";
         
         pattern = Pattern.compile( loopPattern, Pattern.DOTALL );
         m = pattern.matcher( commandStr );      
         
         if( m.find() )
         {
            String afterLoop =  m.group( 1 ).trim();
            afterLoop = this.macrosFormat.format( afterLoop, e, mainServ, connection, options );
            resultBuf.append( afterLoop.trim() );
         }
      }
      else
      {   
         commandStr = this.macrosFormat.format( commandStr, e, mainServ, connection, options );
         
         resultBuf.append( commandStr );       
      }   
      
      return resultBuf.toString();
   }
   
   private String getParamMulti( String commands )
   {
      Matcher matcher = paramMultiPattern.matcher( commands );
      if( matcher.find() )
      {
         String prefix =  matcher.group( 1 );
         
         String param = this.config.get( prefix, "" );
         // команды заведены отдельными параметрами
         if( Utils.isBlankString( param ) )                  
         {
            param = "";
            for( ParameterMap params : this.config.subIndexed( prefix + "." ).values() )
            {
               String command = params.get( "", null );
               if( Utils.notBlankString( command ) )
               {                        
                  param += command +  "\n";
               }
            }
         }
                              
         return param;               
      }
      
      return commands;
      
   }

   private StringBuffer processBlock( String ruleText, List<InetServ> servs, ServiceActivatorEvent e, InetConnection connection, Set<Integer> options )
   {
      StringBuffer result = new StringBuffer();
      
      List<PatternItem> items = new ArrayList<PatternItem>( 10 );
      Map<String, Integer> letterMaxNumbers = new HashMap<String, Integer>();
      
      Pattern pattern = Pattern.compile( "\\{([A-Z]+)(\\d+)\\}" );
      Matcher m = pattern.matcher( ruleText );
      
      while( m.find() )
      {
         String letter = m.group( 1 );
         int number = Utils.parseInt( m.group( 2 ), 0 );
         
         PatternItem item = new PatternItem();
         item.number = number;
         item.letter = letter;
         
         items.add( item );
         
         Integer maxNumber = letterMaxNumbers.get( letter );
         if( maxNumber == null || maxNumber < number )
         {
            letterMaxNumbers.put( letter, number );
         }
      }
            
      final int size = servs.size();
      
      for( int i = 0; i < size; i++ )
      {
         //String address = IPUtils.convertLongIpToString( Utils.parseLong( addreses[i], 0 ) );
         String addressRule = new String( ruleText );
         InetServ serv = servs.get( i );
         
         for( PatternItem item : items )
         {
            int number = i*(letterMaxNumbers.get( item.letter ) + 1) + item.number;
            addressRule = addressRule.replaceAll(
                  "\\{" + item.letter + item.number + "\\}",
                  "{" + item.letter + number + "}" );
         }
         
         
         
         String str = addressRule;
         
         str = this.macrosFormat.format( str, e, serv, connection, options );
         result.append( str + "\n"  );
      }
      return result;
   }   

   
   private static class PatternItem
   {
      public String letter;
      public int number;
   }
      
}

   @Override
   protected Object executeCommands( ServiceActivatorEvent e, InetServ serv, InetConnection connection, Set<Integer> options, String[] commands )
      throws Exception
   {

      InetServ inetServ = e.getNewInetServ()!=null? e.getNewInetServ() : e.getOldInetServ();

      if( e == null )
      {
            return super.executeCommands( e, serv, connection, options, commands );
      }