import static org.jcodec.common.Tuple._2;
import static org.jcodec.common.Tuple._3;

import org.jcodec.common.Codec;
import org.jcodec.common.Demuxer;
import org.jcodec.common.DemuxerTrack;
import org.jcodec.common.DemuxerTrackMeta;
import org.jcodec.common.Format;
import org.jcodec.common.JCodecUtil;
import org.jcodec.common.TrackType;
import org.jcodec.common.logging.Logger;
import org.jcodec.common.model.Packet;
import org.jcodec.common.tools.MainUtils;
import org.jcodec.common.tools.MainUtils.Cmd;
import org.jcodec.common.tools.MathUtil;
import org.jcodec.samples.transcode.Transcoder.Filter;
import org.jcodec.samples.transcode.filters.DumpMvFilter;

/**
 * This class is part of JCodec ( www.jcodec.org ) This software is distributed
 * under FreeBSD License
 * 
 * Transcoder command line.
 * 
 * @author The JCodec project
 * 
 */
sclass TranscodeMain {
  private static final String FLAG_SEEK_FRAMES = "seek-frames";
  private static final String FLAG_MAX_FRAMES = "max-frames";

  private static final String FLAG_OUTPUT_AUDIO_CODEC = "o:ac";
  private static final String FLAG_INPUT_AUDIO_CODEC = "i:ac";
  private static final String FLAG_OUTPUT_VIDEO_CODEC = "o:vc";
  private static final String FLAG_INPUT_VIDEO_CODEC = "i:vc";
  private static final String FLAG_OUTPUT_FORMAT = "o:f";
  private static final String FLAG_INPUT_FORMAT = "i:f";

  private static final String FLAG_PROFILE = "profile";
  private static final String FLAG_INTERLACED = "interlaced";

  private static final String FLAG_DUMPMV = "dumpMv";
  private static final String FLAG_DUMPMVJS = "dumpMvJs";

  private static final String FLAG_DOWNSCALE = "downscale";

  private static Map<String, Format> extensionToF = new HashMap<String, Format>();
  private static Map<String, Codec> extensionToC = new HashMap<String, Codec>();
  private static Map<Format, Codec> videoCodecsForF = new HashMap<Format, Codec>();
  private static Map<Format, Codec> audioCodecsForF = new HashMap<Format, Codec>();
  private static Set<Codec> supportedDecoders = new HashSet<Codec>();

  static {
      extensionToF.put("mpg", Format.MPEG_PS);
      extensionToF.put("mpeg", Format.MPEG_PS);
      extensionToF.put("m2p", Format.MPEG_PS);
      extensionToF.put("ps", Format.MPEG_PS);
      extensionToF.put("vob", Format.MPEG_PS);
      extensionToF.put("evo", Format.MPEG_PS);
      extensionToF.put("mod", Format.MPEG_PS);
      extensionToF.put("tod", Format.MPEG_PS);

      extensionToF.put("ts", Format.MPEG_TS);
      extensionToF.put("m2t", Format.MPEG_TS);

      extensionToF.put("mp4", Format.MOV);
      extensionToF.put("m4a", Format.MOV);
      extensionToF.put("m4v", Format.MOV);
      extensionToF.put("mov", Format.MOV);
      extensionToF.put("3gp", Format.MOV);

      extensionToF.put("mkv", Format.MKV);
      extensionToF.put("webm", Format.MKV);

      extensionToF.put("264", Format.H264);
      extensionToF.put("raw", Format.RAW);
      extensionToF.put("", Format.RAW);
      extensionToF.put("flv", Format.FLV);
      extensionToF.put("avi", Format.AVI);
      extensionToF.put("jpg", Format.IMG);
      extensionToF.put("jpeg", Format.IMG);
      extensionToF.put("png", Format.IMG);

      extensionToF.put("mjp", Format.MJPEG);

      extensionToF.put("ivf", Format.IVF);
      extensionToF.put("y4m", Format.Y4M);
      extensionToF.put("wav", Format.WAV);

      extensionToC.put("mpg", Codec.MPEG2);
      extensionToC.put("mpeg", Codec.MPEG2);
      extensionToC.put("m2p", Codec.MPEG2);
      extensionToC.put("ps", Codec.MPEG2);
      extensionToC.put("vob", Codec.MPEG2);
      extensionToC.put("evo", Codec.MPEG2);
      extensionToC.put("mod", Codec.MPEG2);
      extensionToC.put("tod", Codec.MPEG2);
      extensionToC.put("ts", Codec.MPEG2);
      extensionToC.put("m2t", Codec.MPEG2);
      extensionToC.put("m4a", Codec.AAC);
      extensionToC.put("mkv", Codec.H264);
      extensionToC.put("webm", Codec.VP8);
      extensionToC.put("264", Codec.H264);
      extensionToC.put("raw", Codec.RAW);
      extensionToC.put("jpg", Codec.JPEG);
      extensionToC.put("jpeg", Codec.JPEG);
      extensionToC.put("png", Codec.PNG);
      extensionToC.put("mjp", Codec.JPEG);
      extensionToC.put("y4m", Codec.RAW);

      videoCodecsForF.put(Format.MPEG_PS, Codec.MPEG2);
      audioCodecsForF.put(Format.MPEG_PS, Codec.MP2);
      videoCodecsForF.put(Format.MOV, Codec.H264);
      audioCodecsForF.put(Format.MOV, Codec.AAC);
      videoCodecsForF.put(Format.MKV, Codec.VP8);
      audioCodecsForF.put(Format.MKV, Codec.VORBIS);
      audioCodecsForF.put(Format.WAV, Codec.PCM);
      videoCodecsForF.put(Format.H264, Codec.H264);
      videoCodecsForF.put(Format.RAW, Codec.RAW);
      videoCodecsForF.put(Format.FLV, Codec.H264);
      videoCodecsForF.put(Format.AVI, Codec.MPEG4);
      videoCodecsForF.put(Format.IMG, Codec.PNG);
      videoCodecsForF.put(Format.MJPEG, Codec.JPEG);
      videoCodecsForF.put(Format.IVF, Codec.VP8);
      videoCodecsForF.put(Format.Y4M, Codec.RAW);

      supportedDecoders.add(Codec.AAC);
      supportedDecoders.add(Codec.H264);
      supportedDecoders.add(Codec.JPEG);
      supportedDecoders.add(Codec.MPEG2);
      supportedDecoders.add(Codec.PCM);
      supportedDecoders.add(Codec.PNG);
      supportedDecoders.add(Codec.PRORES);
      supportedDecoders.add(Codec.RAW);
      supportedDecoders.add(Codec.VP8);
  }

  public static void main(String[] args) throws Exception {
      Cmd cmd = MainUtils.parseArguments(args);
      if (args.length < 2) {
          MainUtils.printHelpVarArgs(new HashMap<String, String>() {
              {

                  put(FLAG_INPUT_FORMAT, "Input format [default=auto].");
                  put(FLAG_OUTPUT_FORMAT, "Output format [default=auto].");
                  put(FLAG_INPUT_VIDEO_CODEC, "Input video codec [default=auto].");
                  put(FLAG_OUTPUT_VIDEO_CODEC, "Output video codec [default=auto].");
                  put(FLAG_INPUT_AUDIO_CODEC, "Input audio codec [default=auto].");
                  put(FLAG_OUTPUT_AUDIO_CODEC, "Output audio codec [default=auto].");
                  put(FLAG_SEEK_FRAMES, "Seek frames");
                  put(FLAG_MAX_FRAMES, "Max frames");
                  put(FLAG_PROFILE, "Profile to use (supported by some encoders).");
                  put(FLAG_INTERLACED, "Encode output as interlaced (supported by Prores encoder).");
                  put(FLAG_DUMPMV, "Dump motion vectors (supported by h.264 decoder).");
                  put(FLAG_DUMPMVJS, "Dump motion vectors in form of JASON file (supported by h.264 decoder).");
                  put(FLAG_DOWNSCALE, "Decode frames in downscale (supported by MPEG, Prores and Jpeg decoders).");
              }
          }, "input", "output");
          return;
      }

      String input = cmd.getArg(0);
      String output = cmd.getArg(1);

      String inputFormatRaw = cmd.getStringFlag(FLAG_INPUT_FORMAT);
      Format inputFormat;
      if (inputFormatRaw == null) {
          inputFormat = getFormatFromExtension(input);
          if (inputFormat != Format.IMG) {
              Format detectFormat = JCodecUtil.detectFormat(new File(input));
              if (detectFormat != null)
                  inputFormat = detectFormat;
          }
      } else {
          inputFormat = Format.valueOf(inputFormatRaw.toUpperCase());
      }
      if (inputFormat == null) {
          Logger.error("Input format could not be detected");
          return;
      }

      String outputFormatRaw = cmd.getStringFlag(FLAG_OUTPUT_FORMAT);
      Format outputFormat;
      if (outputFormatRaw == null) {
          outputFormat = getFormatFromExtension(output);
      } else {
          outputFormat = Format.valueOf(outputFormatRaw.toUpperCase());
      }

      int videoTrackNo = -1;
      String inputCodecVideoRaw = cmd.getStringFlag(FLAG_INPUT_VIDEO_CODEC);
      _3<Integer, Integer, Codec> inputCodecVideo = null;
      if (inputCodecVideoRaw == null) {
          if (inputFormat == Format.IMG) {
              inputCodecVideo = _3(0, 0, getCodecFromExtension(input));
          } else if (inputFormat.isVideo()) {
              inputCodecVideo = selectSuitableTrack(input, inputFormat, TrackType.VIDEO);
          }
      } else {
          inputCodecVideo = _3(0, 0, Codec.valueOf(inputCodecVideoRaw.toUpperCase()));
      }

      String outputCodecVideoRaw = cmd.getStringFlag(FLAG_OUTPUT_VIDEO_CODEC);
      Codec outputCodecVideo = null;
      boolean videoCopy = false;
      if (outputCodecVideoRaw == null) {
          outputCodecVideo = getCodecFromExtension(output);
          if (outputCodecVideo == null)
              outputCodecVideo = getFirstVideoCodecForFormat(outputFormat);
      } else {
          if ("copy".equalsIgnoreCase(outputCodecVideoRaw)) {
              videoCopy = true;
              outputCodecVideo = inputCodecVideo.v2;
          } else if("none".equalsIgnoreCase(outputCodecVideoRaw)) {
              outputCodecVideo = null;
              inputCodecVideo = null;
          } else {
              outputCodecVideo = Codec.valueOf(outputCodecVideoRaw.toUpperCase());
          }
      }

      String inputCodecAudioRaw = cmd.getStringFlag(FLAG_INPUT_AUDIO_CODEC);
      _3<Integer, Integer, Codec> inputCodecAudio = null;
      if (inputCodecAudioRaw == null) {
          if (inputFormat.isAudio()) {
              inputCodecAudio = selectSuitableTrack(input, inputFormat, TrackType.AUDIO);
          }
      } else {
          inputCodecAudio = _3(0, 0, Codec.valueOf(inputCodecAudioRaw.toUpperCase()));
      }

      String outputCodecAudioRaw = cmd.getStringFlag(FLAG_OUTPUT_AUDIO_CODEC);
      Codec outputCodecAudio = null;
      boolean audioCopy = false;
      if (outputCodecAudioRaw == null) {
          if (outputFormat.isAudio())
              outputCodecAudio = getFirstAudioCodecForFormat(outputFormat);
      } else {
          if ("copy".equalsIgnoreCase(outputCodecAudioRaw)) {
              audioCopy = true;
              outputCodecAudio = inputCodecAudio.v2;
          } else if("none".equalsIgnoreCase(outputCodecVideoRaw)) {
              outputCodecAudio = null;
              inputCodecAudio = null;
          } else {
              outputCodecAudio = Codec.valueOf(outputCodecAudioRaw.toUpperCase());
          }
      }
      if (inputCodecAudio == null)
          outputCodecAudio = null;

      List<Filter> filters = new ArrayList<Filter>();
      if (cmd.getBooleanFlag(FLAG_DUMPMV))
          filters.add(new DumpMvFilter(false));
      else if (cmd.getBooleanFlag(FLAG_DUMPMVJS))
          filters.add(new DumpMvFilter(true));

      Transcoder transcoder = new Transcoder(cmd.getArg(0), cmd.getArg(1), inputFormat, outputFormat, inputCodecVideo,
              outputCodecVideo, inputCodecAudio, outputCodecAudio, videoCopy, audioCopy, filters);
      transcoder.setSeekFrames(cmd.getIntegerFlagD(FLAG_SEEK_FRAMES, 0));
      transcoder.setMaxFrames(cmd.getIntegerFlagD(FLAG_MAX_FRAMES, Integer.MAX_VALUE));
      transcoder.setProfile(cmd.getStringFlag(FLAG_PROFILE));
      transcoder.setInterlaced(cmd.getBooleanFlagD(FLAG_INTERLACED, false));
      Integer downscale = cmd.getIntegerFlagD(FLAG_DOWNSCALE, 1);
      if (downscale != null && (1 << MathUtil.log2(downscale)) != downscale) {
          Logger.error(
                  "Only values [2, 4, 8] are supported for " + FLAG_DOWNSCALE + ", the option will have no effect.");
      } else {
          transcoder.setDownscale(downscale);
      }
      transcoder.transcode();
  }

  private static Codec getFirstAudioCodecForFormat(Format inputFormat) {
      return audioCodecsForF.get(inputFormat);
  }

  private static Codec getFirstVideoCodecForFormat(Format inputFormat) {
      return videoCodecsForF.get(inputFormat);
  }

  private static Codec detectVideoDecoder(DemuxerTrack track) throws IOException {
      DemuxerTrackMeta meta = track.getMeta();
      if (meta != null) {
          Codec codec = meta.getCodec();
          if (codec != null)
              return codec;
      }
      Packet packet = track.nextFrame();
      if (packet == null)
          return null;

      return JCodecUtil.detectDecoder(packet.getData());
  }

  private static _3<Integer, Integer, Codec> selectSuitableTrack(String input, Format format, TrackType targetType)
          throws IOException {
      _2<Integer, Demuxer> demuxerPid;
      if (format == Format.MPEG_TS) {
          demuxerPid = JCodecUtil.createM2TSDemuxer(new File(input), targetType);
      } else {
          demuxerPid = _2(0, JCodecUtil.createDemuxer(format, new File(input)));
      }
      if(demuxerPid == null || demuxerPid.v1 == null)
          return null;
      int trackNo = 0;
      List<? extends DemuxerTrack> tracks = targetType == TrackType.VIDEO ? demuxerPid.v1.getVideoTracks()
              : demuxerPid.v1.getAudioTracks();
      for (DemuxerTrack demuxerTrack : tracks) {
          Codec codec = detectVideoDecoder(demuxerTrack);
          if (supportedDecoders.contains(codec)) {
              return _3(demuxerPid.v0, trackNo, codec);
          }
          trackNo++;
      }
      return null;
  }

  private static Format getFormatFromExtension(String output) {
      String extension = output.replaceFirst(".*\\.([^\\.]+$)", "$1");
      return extensionToF.get(extension);
  }

  private static Codec getCodecFromExtension(String output) {
      String extension = output.replaceFirst(".*\\.([^\\.]+$)", "$1");
      return extensionToC.get(extension);
  }

  public static Set<Format> formats(Format... formats) {
      return new HashSet<Format>(Arrays.asList(formats));
  }

  public static Set<Codec> codecs(Codec... codecs) {
      return new HashSet<Codec>(Arrays.asList(codecs));
  }
}