/*
    * Licensed to The Apereo Foundation under one or more contributor license
    * agreements. See the NOTICE file distributed with this work for additional
    * information regarding copyright ownership.
    *
    *
    * The Apereo Foundation licenses this file to you under the Educational
    * Community 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://opensource.org/licenses/ecl2.txt
   *
   * 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.opencastproject.waveform.ffmpeg;
  
  import org.opencastproject.job.api.AbstractJobProducer;
  import org.opencastproject.job.api.Job;
  import org.opencastproject.mediapackage.Attachment;
  import org.opencastproject.mediapackage.MediaPackageElement.Type;
  import org.opencastproject.mediapackage.MediaPackageElementBuilder;
  import org.opencastproject.mediapackage.MediaPackageElementBuilderFactory;
  import org.opencastproject.mediapackage.MediaPackageElementParser;
  import org.opencastproject.mediapackage.MediaPackageException;
  import org.opencastproject.mediapackage.Track;
  import org.opencastproject.security.api.OrganizationDirectoryService;
  import org.opencastproject.security.api.SecurityService;
  import org.opencastproject.security.api.UserDirectoryService;
  import org.opencastproject.serviceregistry.api.ServiceRegistry;
  import org.opencastproject.serviceregistry.api.ServiceRegistryException;
  import org.opencastproject.util.IoSupport;
  import org.opencastproject.util.LoadUtil;
  import org.opencastproject.util.NotFoundException;
  import org.opencastproject.waveform.api.WaveformService;
  import org.opencastproject.waveform.api.WaveformServiceException;
  import org.opencastproject.workspace.api.Workspace;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.FilenameUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.osgi.service.cm.ConfigurationException;
  import org.osgi.service.cm.ManagedService;
  import org.osgi.service.component.ComponentContext;
  import org.osgi.service.component.annotations.Activate;
  import org.osgi.service.component.annotations.Component;
  import org.osgi.service.component.annotations.Reference;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.net.URI;
  import java.util.Arrays;
  import java.util.Dictionary;
  import java.util.List;
  import java.util.concurrent.TimeUnit;
  
  
  /**
   * This service creates a waveform image from a media file with at least one audio channel.
   * This will be done using ffmpeg.
   */
  @Component(
      immediate = true,
      service = { WaveformService.class,ManagedService.class },
      property = {
          "service.description=Waveform Service"
      }
  )
  public class WaveformServiceImpl extends AbstractJobProducer implements WaveformService, ManagedService {
  
    /** The logging facility */
    protected static final Logger logger = LoggerFactory.getLogger(WaveformServiceImpl.class);
  
    /** Path to the executable */
    protected String binary = DEFAULT_FFMPEG_BINARY;
  
    /** The key to look for in the service configuration file to override the DEFAULT_WAVEFORM_JOB_LOAD */
    public static final String WAVEFORM_JOB_LOAD_CONFIG_KEY = "job.load.waveform";
  
    /** The default job load of a waveform job */
    public static final float DEFAULT_WAVEFORM_JOB_LOAD = 0.1f;
  
    /** The key to look for in the service configuration file to override the DEFAULT_FFMPEG_BINARY */
    public static final String FFMPEG_BINARY_CONFIG_KEY = "org.opencastproject.composer.ffmpeg.path";
  
    /** The default path to the ffmpeg binary */
    public static final String DEFAULT_FFMPEG_BINARY = "ffmpeg";
  
   /** The default waveform image scale algorithm */
   public static final String DEFAULT_WAVEFORM_SCALE = "lin";
 
   /** The key to look for in the service configuration file to override the DEFAULT_WAVEFORM_SCALE */
   public static final String WAVEFORM_SCALE_CONFIG_KEY = "waveform.scale";
 
   /** The default value if the waveforms (per audio channel) should be renderen next to each other (if true)
    * or on top of each other (if false) */
   public static final boolean DEFAULT_WAVEFORM_SPLIT_CHANNELS = false;
 
   /** The key to look for in the service configuration file to override the DEFAULT_WAVEFORM_SPLIT_CHANNELS */
   public static final String WAVEFORM_SPLIT_CHANNELS_CONFIG_KEY = "waveform.split.channels";
 
   /** The default waveform colors per audio channel */
   public static final String[] DEFAULT_WAVEFORM_COLOR = { "black" };
 
   /** The key to look for in the service configuration file to override the DEFAULT_WAVEFORM_COLOR */
   public static final String WAVEFORM_COLOR_CONFIG_KEY = "waveform.color";
 
   public static final String DEFAULT_WAVEFORM_FILTER_MODE = "peak";
 
   public static final String WAVEFORM_FILTER_MODE_CONFIG_KEY = "waveform.filter-mode";
 
   /** The default filter to be optionally prepended to the showwavespic filter */
   public static final String DEFAULT_WAVEFORM_FILTER_PRE = null;
 
   /** The key to look for in the service configuration file to override the DEFAULT_WAVEFORM_FILTER_PRE */
   public static final String WAVEFORM_FILTER_PRE_CONFIG_KEY = "waveform.filter.pre";
 
   /** The default filter to be optionally appended to the showwavespic filter */
   public static final String DEFAULT_WAVEFORM_FILTER_POST = null;
 
   /** The key to look for in the service configuration file to override the DEFAULT_WAVEFORM_FILTER_POST */
   public static final String WAVEFORM_FILTER_POST_CONFIG_KEY = "waveform.filter.post";
 
   /** Resulting collection in the working file repository */
   public static final String COLLECTION_ID = "waveform";
 
   /** List of available operations on jobs */
   enum Operation {
     Waveform
   };
 
   /** The waveform job load */
   private float waveformJobLoad = DEFAULT_WAVEFORM_JOB_LOAD;
 
   /** The waveform image scale algorithm */
   private String waveformScale = DEFAULT_WAVEFORM_SCALE;
 
   /** The value if the waveforms (per audio channel) should be rendered next to each other (if true)
    * or on top of each other (if false) */
   private boolean waveformSplitChannels = DEFAULT_WAVEFORM_SPLIT_CHANNELS;
 
   /** The waveform colors per audio channel */
   private String[] waveformColor = DEFAULT_WAVEFORM_COLOR;
 
   private String waveformFilterMode = DEFAULT_WAVEFORM_FILTER_MODE;
 
   /** Filter to be prepended to the showwavespic filter */
   private String waveformFilterPre = DEFAULT_WAVEFORM_FILTER_PRE;
 
   /** Filter to be appended to the showwavespic filter */
   private String waveformFilterPost = DEFAULT_WAVEFORM_FILTER_POST;
 
   /** Reference to the service registry */
   private ServiceRegistry serviceRegistry = null;
 
   /** The workspace to use when retrieving remote media files */
   private Workspace workspace = null;
 
   /** The security service */
   private SecurityService securityService = null;
 
   /** The user directory service */
   private UserDirectoryService userDirectoryService = null;
 
   /** The organization directory service */
   private OrganizationDirectoryService organizationDirectoryService = null;
 
   public WaveformServiceImpl() {
     super(JOB_TYPE);
   }
 
   @Override
   @Activate
   public void activate(ComponentContext cc) {
     super.activate(cc);
     logger.info("Activate ffmpeg waveform service");
     final String path = cc.getBundleContext().getProperty(FFMPEG_BINARY_CONFIG_KEY);
     binary = (path == null ? DEFAULT_FFMPEG_BINARY : path);
     logger.debug("ffmpeg binary set to {}", binary);
   }
 
   @Override
   public void updated(Dictionary<String, ?> properties) throws ConfigurationException {
     if (properties == null) {
       return;
     }
     logger.debug("Configuring the waveform service");
     waveformJobLoad = LoadUtil.getConfiguredLoadValue(properties,
             WAVEFORM_JOB_LOAD_CONFIG_KEY, DEFAULT_WAVEFORM_JOB_LOAD, serviceRegistry);
 
     Object val = properties.get(WAVEFORM_SCALE_CONFIG_KEY);
     if (val != null) {
       if (StringUtils.isNotEmpty((String) val)) {
         if (!"lin".equals(val) && !"log".equals(val)) {
           logger.warn("Waveform scale configuration value '{}' is not in set of predefined values (lin, log). "
                   + "The waveform image extraction job may fail.", val);
         }
         waveformScale = (String) val;
       }
     }
 
     val = properties.get(WAVEFORM_SPLIT_CHANNELS_CONFIG_KEY);
     if (val != null) {
       waveformSplitChannels = Boolean.parseBoolean((String) val);
     }
 
     val = properties.get(WAVEFORM_COLOR_CONFIG_KEY);
     if (val != null && StringUtils.isNotEmpty((String) val)) {
       String colorValue = (String) val;
       if (StringUtils.isNotEmpty(colorValue) && StringUtils.isNotBlank(colorValue)) {
         waveformColor = StringUtils.split(colorValue, ", |:;");
       }
     }
 
     val = properties.get(WAVEFORM_FILTER_MODE_CONFIG_KEY);
     if (val != null && StringUtils.isNotEmpty((String) val)) {
       if (!"average".equals(val) && !"peak".equals(val)) {
         logger.warn("Waveform filter mode configuration value '{}' is not in set of predefined values (average, peak). "
                 + "The waveform image extraction job may fail.", val);
       }
       waveformFilterMode = (String) val;
     }
 
     val = properties.get(WAVEFORM_FILTER_PRE_CONFIG_KEY);
     if (val != null) {
       waveformFilterPre = StringUtils.trimToNull((String) val);
     } else {
       waveformFilterPre = null;
     }
 
     val = properties.get(WAVEFORM_FILTER_POST_CONFIG_KEY);
     if (val != null) {
       waveformFilterPost = StringUtils.trimToNull((String) val);
     } else {
       waveformFilterPost = null;
     }
   }
 
   /**
    * {@inheritDoc}
    *
    * @see org.opencastproject.waveform.api.WaveformService#createWaveformImage(org.opencastproject.mediapackage.Track,
    *         int, int, int, int, String)
    */
   @Override
   public Job createWaveformImage(
       Track sourceTrack, int pixelsPerMinute, int minWidth, int maxWidth, int height, String color
   ) throws MediaPackageException, WaveformServiceException {
     try {
       return serviceRegistry.createJob(jobType, Operation.Waveform.toString(),
           Arrays.asList(
               MediaPackageElementParser.getAsXml(sourceTrack),
               Integer.toString(pixelsPerMinute),
               Integer.toString(minWidth),
               Integer.toString(maxWidth),
               Integer.toString(height),
               color
           ),
           waveformJobLoad
       );
     } catch (ServiceRegistryException ex) {
       throw new WaveformServiceException("Unable to create waveform job", ex);
     }
   }
 
   /**
    * {@inheritDoc}
    *
    * @see org.opencastproject.job.api.AbstractJobProducer#process(org.opencastproject.job.api.Job)
    */
   @Override
   protected String process(Job job) throws Exception {
     Operation op = null;
     String operation = job.getOperation();
     List<String> arguments = job.getArguments();
     try {
       op = Operation.valueOf(operation);
       switch (op) {
         case Waveform:
           Track track = (Track) MediaPackageElementParser.getFromXml(arguments.get(0));
           int pixelsPerMinute = Integer.parseInt(arguments.get(1));
           int minWidth = Integer.parseInt(arguments.get(2));
           int maxWidth = Integer.parseInt(arguments.get(3));
           int height = Integer.parseInt(arguments.get(4));
           String color = arguments.get(5);
           Attachment waveformMpe = extractWaveform(track, pixelsPerMinute, minWidth, maxWidth, height, color);
           return MediaPackageElementParser.getAsXml(waveformMpe);
         default:
           throw new ServiceRegistryException("This service can't handle operations of type '" + op + "'");
       }
     } catch (IndexOutOfBoundsException e) {
       throw new ServiceRegistryException("This argument list for operation '" + op + "' does not meet expectations", e);
     } catch (MediaPackageException | WaveformServiceException e) {
       throw new ServiceRegistryException("Error handling operation '" + op + "'", e);
     }
   }
 
   /**
    * Create and run waveform extraction ffmpeg command.
    *
    * @param track source audio/video track with at least one audio channel
    * @param pixelsPerMinute width of waveform image in pixels per minute
    * @param minWidth minimum width of waveform image
    * @param maxWidth maximum width of waveform image
    * @param height height of waveform image
    * @param color color of waveform image
    * @return waveform image attachment
    * @throws WaveformServiceException if processing fails
    */
   private Attachment extractWaveform(
       Track track, int pixelsPerMinute, int minWidth, int maxWidth, int height, String color
   ) throws WaveformServiceException {
     if (!track.hasAudio()) {
       throw new WaveformServiceException("Track has no audio");
     }
 
     // copy source file into workspace
     File mediaFile;
     try {
       mediaFile = workspace.get(track.getURI());
     } catch (NotFoundException e) {
       throw new WaveformServiceException(
           "Error finding the media file in the workspace", e);
     } catch (IOException e) {
       throw new WaveformServiceException(
           "Error reading the media file in the workspace", e);
     }
 
     String waveformFilePath = FilenameUtils.removeExtension(mediaFile.getAbsolutePath())
             .concat('-' + track.getIdentifier()).concat("-waveform.png");
 
     int width = getWaveformImageWidth(track, pixelsPerMinute, minWidth, maxWidth);
 
     // create ffmpeg command
     String[] command = new String[] {
         binary,
         "-nostats", "-nostdin", "-hide_banner",
         "-i", mediaFile.getAbsolutePath(),
         "-lavfi", createWaveformFilter(width, height, color),
         "-frames:v", "1",
         "-an", "-vn", "-sn",
         waveformFilePath
     };
     logger.debug("Start waveform ffmpeg process: {}", StringUtils.join(command, " "));
     logger.info("Create waveform image file for track '{}' at {}", track.getIdentifier(), waveformFilePath);
 
     // run ffmpeg
     ProcessBuilder pb = new ProcessBuilder(command);
     pb.redirectErrorStream(true);
     Process ffmpegProcess = null;
     int exitCode = 1;
     BufferedReader errStream = null;
     try {
       ffmpegProcess = pb.start();
 
       errStream = new BufferedReader(new InputStreamReader(ffmpegProcess.getInputStream()));
       String line = errStream.readLine();
       while (line != null) {
         logger.debug(line);
         line = errStream.readLine();
       }
 
       exitCode = ffmpegProcess.waitFor();
     } catch (IOException ex) {
       throw new WaveformServiceException("Start ffmpeg process failed", ex);
     } catch (InterruptedException ex) {
       throw new WaveformServiceException("Waiting for encoder process exited was interrupted unexpectedly", ex);
     } finally {
       IoSupport.closeQuietly(ffmpegProcess);
       IoSupport.closeQuietly(errStream);
       if (exitCode != 0) {
         try {
           FileUtils.forceDelete(new File(waveformFilePath));
         } catch (IOException e) {
           // it is ok, no output file was generated by ffmpeg
         }
       }
     }
 
     if (exitCode != 0) {
       throw new WaveformServiceException(String.format("The encoder process exited abnormally with exit code %s "
               + "using command\n%s", exitCode, String.join(" ", command)));
     }
 
     // put waveform image into workspace
     FileInputStream waveformFileInputStream = null;
     URI waveformFileUri;
     try {
       waveformFileInputStream = new FileInputStream(waveformFilePath);
       waveformFileUri = workspace.putInCollection(COLLECTION_ID,
               FilenameUtils.getName(waveformFilePath), waveformFileInputStream);
       logger.info("Copied the created waveform to the workspace {}", waveformFileUri);
     } catch (FileNotFoundException ex) {
       throw new WaveformServiceException(String.format("Waveform image file '%s' not found", waveformFilePath), ex);
     } catch (IOException ex) {
       throw new WaveformServiceException(String.format(
               "Can't write waveform image file '%s' to workspace", waveformFilePath), ex);
     } catch (IllegalArgumentException ex) {
       throw new WaveformServiceException(ex);
     } finally {
       IoSupport.closeQuietly(waveformFileInputStream);
       logger.info("Deleted local waveform image file at {}", waveformFilePath);
       FileUtils.deleteQuietly(new File(waveformFilePath));
     }
 
     // create media package element
     MediaPackageElementBuilder mpElementBuilder = MediaPackageElementBuilderFactory.newInstance().newElementBuilder();
     // it is up to the workflow operation handler to set the attachment flavor
     Attachment waveformMpe = (Attachment) mpElementBuilder.elementFromURI(
             waveformFileUri, Type.Attachment, track.getFlavor());
     waveformMpe.generateIdentifier();
     return waveformMpe;
   }
 
   /**
    * Create an ffmpeg waveform filter with parameters based on input track and service configuration.
    *
    * @param width width of waveform image
    * @param height height of waveform image
    * @param color color of waveform image
    * @return ffmpeg filter parameter
    */
   private String createWaveformFilter(int width, int height, String color) {
     StringBuilder filterBuilder = new StringBuilder();
     if (waveformFilterPre != null) {
       filterBuilder.append(waveformFilterPre);
       filterBuilder.append(",");
     }
     String[] waveformOperationColors = null;
     //If the color was set, override the defaults
     if (StringUtils.isNotBlank(color)) {
       waveformOperationColors = StringUtils.split(color, "|");
     } else {
       waveformOperationColors = waveformColor;
     }
     filterBuilder.append("showwavespic=");
     filterBuilder.append("split_channels=");
     filterBuilder.append(waveformSplitChannels ? 1 : 0);
     filterBuilder.append(":s=");
     filterBuilder.append(width);
     filterBuilder.append("x");
     filterBuilder.append(height);
     filterBuilder.append(":scale=");
     filterBuilder.append(waveformScale);
     filterBuilder.append(":filter=");
     filterBuilder.append(waveformFilterMode);
     filterBuilder.append(":colors=");
     filterBuilder.append(StringUtils.join(Arrays.asList(waveformOperationColors), "|"));
     if (waveformFilterPost != null) {
       filterBuilder.append(",");
       filterBuilder.append(waveformFilterPost);
     }
     return filterBuilder.toString();
   }
 
   /**
    * Return the waveform image width build from input track and service configuration.
    *
    * @param track source audio/video track with at least one audio channel
    * @param pixelsPerMinute width of waveform image in pixels per minute
    * @param minWidth minimum width of waveform image
    * @param maxWidth maximum width of waveform image
    * @return waveform image width
    */
   private int getWaveformImageWidth(Track track, int pixelsPerMinute, int minWidth, int maxWidth) {
     int imageWidth = minWidth;
     if (track.getDuration() > 0) {
       int trackDurationMinutes = (int) TimeUnit.MILLISECONDS.toMinutes(track.getDuration());
       if (pixelsPerMinute > 0 && trackDurationMinutes > 0) {
         imageWidth = Math.max(minWidth, trackDurationMinutes * pixelsPerMinute);
         imageWidth = Math.min(maxWidth, imageWidth);
       }
     }
     return imageWidth;
   }
 
   @Override
   protected ServiceRegistry getServiceRegistry() {
     return serviceRegistry;
   }
 
   @Override
   protected SecurityService getSecurityService() {
     return securityService;
   }
 
   @Override
   protected UserDirectoryService getUserDirectoryService() {
     return userDirectoryService;
   }
 
   @Override
   protected OrganizationDirectoryService getOrganizationDirectoryService() {
     return organizationDirectoryService;
   }
 
   @Reference
   public void setServiceRegistry(ServiceRegistry serviceRegistry) {
     this.serviceRegistry = serviceRegistry;
   }
 
   @Reference
   public void setSecurityService(SecurityService securityService) {
     this.securityService = securityService;
   }
 
   @Reference
   public void setUserDirectoryService(UserDirectoryService userDirectoryService) {
     this.userDirectoryService = userDirectoryService;
   }
 
   @Reference
   public void setOrganizationDirectoryService(OrganizationDirectoryService organizationDirectoryService) {
     this.organizationDirectoryService = organizationDirectoryService;
   }
 
   @Reference
   public void setWorkspace(Workspace workspace) {
     this.workspace = workspace;
   }
 }