package org.apache.maven.plugin.surefire.runorder;

 /*

  * 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.

  */

 import java.io.BufferedReader;

 import java.io.File;

 import java.io.FileNotFoundException;

 import java.io.FileOutputStream;

 import java.io.FileReader;

 import java.io.IOException;

 import java.io.PrintWriter;

 import java.io.Reader;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.Comparator;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import org.apache.maven.surefire.report.ReportEntry;

 /**

  * @author Kristian Rosenvold

  */

 public class RunEntryStatisticsMap

 {

     private final Map runEntryStatistics;

     public RunEntryStatisticsMap( Map runEntryStatistics )

     {

         this.runEntryStatistics = Collections.synchronizedMap( runEntryStatistics );

     }

     public RunEntryStatisticsMap()

     {

         this( new HashMap() );

     }

     public static RunEntryStatisticsMap fromFile( File file )

     {

         if ( file.exists() )

         {

             try

             {

                 FileReader fileReader = new FileReader( file );

                 return fromReader( fileReader );

             }

             catch ( FileNotFoundException e )

             {

                 throw new RuntimeException( e );

             }

             catch ( IOException e1 )

             {

                 throw new RuntimeException( e1 );

             }

         }

         return new RunEntryStatisticsMap();

     }

     static RunEntryStatisticsMap fromReader( Reader fileReader )

         throws IOException

     {

         Map result = new HashMap();

         BufferedReader bufferedReader = new BufferedReader( fileReader );

         String line = bufferedReader.readLine();

         while ( line != null )

         {

             if ( !line.startsWith( "#" ) )

             {

                 final RunEntryStatistics stats = RunEntryStatistics.fromString( line );

                 result.put( stats.getTestName(), stats );

             }

             line = bufferedReader.readLine();

         }

         return new RunEntryStatisticsMap( result );

     }

     public void serialize( File file )

         throws FileNotFoundException

     {

         FileOutputStream fos = new FileOutputStream( file );

         PrintWriter printWriter = new PrintWriter( fos );

         List items = new ArrayList( runEntryStatistics.values() );

         Collections.sort( items, new RunCountComparator() );

         RunEntryStatistics item;

         for ( Iterator iter = items.iterator(); iter.hasNext(); )

         {

             item = (RunEntryStatistics) iter.next();

             printWriter.println( item.getAsString() );

         }

         printWriter.close();

     }

     public RunEntryStatistics findOrCreate( ReportEntry reportEntry )

     {

         final RunEntryStatistics item = (RunEntryStatistics) runEntryStatistics.get( reportEntry.getName() );

         return item != null ? item : RunEntryStatistics.fromReportEntry( reportEntry );

     }

     public RunEntryStatistics createNextGeneration( ReportEntry reportEntry )

     {

         final RunEntryStatistics newItem = findOrCreate( reportEntry );

         final Integer elapsed = reportEntry.getElapsed();

         return newItem.nextGeneration( elapsed != null ? elapsed.intValue() : 0 );

     }

     public RunEntryStatistics createNextGenerationFailure( ReportEntry reportEntry )

     {

         final RunEntryStatistics newItem = findOrCreate( reportEntry );

         final Integer elapsed = reportEntry.getElapsed();

         return newItem.nextGenerationFailure( elapsed != null ? elapsed.intValue() : 0 );

     }

     public void add( RunEntryStatistics item )

     {

         runEntryStatistics.put( item.getTestName(), item );

     }

     class RunCountComparator

         implements Comparator

     {

         public int compare( Object o, Object o1 )

         {

             RunEntryStatistics re = (RunEntryStatistics) o;

             RunEntryStatistics re1 = (RunEntryStatistics) o1;

             int runtime = re.getSuccessfulBuilds() - re1.getSuccessfulBuilds();

             if ( runtime == 0 )

             {

                 return re.getRunTime() - re1.getRunTime();

             }

             return runtime;

         }

     }

     public List getPrioritizedTestsClassRunTime( List testsToRun, int threadCount )

     {

         final List prioritizedTests = getPrioritizedTests( testsToRun, new TestRuntimeComparator() );

         ThreadedExecutionScheduler threadedExecutionScheduler = new ThreadedExecutionScheduler( threadCount );

         for ( Iterator prioritizedTest = prioritizedTests.iterator(); prioritizedTest.hasNext(); )

         {

             threadedExecutionScheduler.addTest( (PrioritizedTest) prioritizedTest.next() );

         }

         return threadedExecutionScheduler.getResult();

     }

     public List getPrioritizedTestsByFailureFirst( List testsToRun )

     {

         final List prioritizedTests = getPrioritizedTests( testsToRun, new LeastFailureComparator() );

         return transformToClasses( prioritizedTests );

     }

     private List getPrioritizedTests( List testsToRun, Comparator priorityComparator )

     {

         Map classPriorities = getPriorities( priorityComparator );

         List tests = new ArrayList();

         for ( Iterator iter = testsToRun.iterator(); iter.hasNext(); )

         {

             Class clazz = (Class) iter.next();

             Priority pri = (Priority) classPriorities.get( clazz.getName() );

             if ( pri == null )

             {

                 pri = Priority.newTestClassPriority( clazz.getName() );

             }

             PrioritizedTest prioritizedTest = new PrioritizedTest( clazz, pri );

             tests.add( prioritizedTest );

         }

         Collections.sort( tests, new PrioritizedTestComparator() );

         return tests;

     }

     private List transformToClasses( List tests )

     {

         List result = new ArrayList();

         for ( int i = 0; i < tests.size(); i++ )

         {

             result.add( ( (PrioritizedTest) tests.get( i ) ).getClazz() );

         }

         return result;

     }

     public Map getPriorities( Comparator priorityComparator )

     {

         Map priorities = new HashMap();

         for ( Iterator iter = runEntryStatistics.keySet().iterator(); iter.hasNext(); )

         {

             String testNames = (String) iter.next();

             String clazzName = extractClassName( testNames );

             Priority priority = (Priority) priorities.get( clazzName );

             if ( priority == null )

             {

                 priority = new Priority( clazzName );

                 priorities.put( clazzName, priority );

             }

             RunEntryStatistics itemStat = (RunEntryStatistics) runEntryStatistics.get( testNames );

             priority.addItem( itemStat );

         }

         List items = new ArrayList( priorities.values() );

         Collections.sort( items, priorityComparator );

         Map result = new HashMap();

         int i = 0;

         for ( Iterator iter = items.iterator(); iter.hasNext(); )

         {

             Priority pri = (Priority) iter.next();

             pri.setPriority( i++ );

             result.put( pri.getClassName(), pri );

         }

         return result;

     }

     class PrioritizedTestComparator

         implements Comparator

     {

         public int compare( Object o, Object o1 )

         {

             PrioritizedTest re = (PrioritizedTest) o;

             PrioritizedTest re1 = (PrioritizedTest) o1;

             return re.getPriority() - re1.getPriority();

         }

     }

     class TestRuntimeComparator

         implements Comparator

     {

         public int compare( Object o, Object o1 )

         {

             Priority re = (Priority) o;

             Priority re1 = (Priority) o1;

             return re1.getTotalRuntime() - re.getTotalRuntime();

         }

     }

     class LeastFailureComparator

         implements Comparator

     {

         public int compare( Object o, Object o1 )

         {

             Priority re = (Priority) o;

             Priority re1 = (Priority) o1;

             return re.getMinSuccessRate() - re1.getMinSuccessRate();

         }

     }

     private static final Pattern PARENS = Pattern.compile( "^" + "[^\\(\\)]+" //non-parens

                                                                + "\\((" // then an open-paren (start matching a group)

                                                                + "[^\\\\(\\\\)]+" //non-parens

                                                                + ")\\)" + "$" ); // then a close-paren (end group match)

     String extractClassName( String displayName )

     {

         Matcher m = PARENS.matcher( displayName );

         if ( !m.find() )

         {

             return displayName;

         }

         return m.group( 1 );

     }

 }