/*
 * Copyright (c) 2015 David Schulte
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

package de.arcus.playmusiclib;

import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.os.ParcelFileDescriptor;
import android.support.v4.content.FileProvider;
import android.support.v4.provider.DocumentFile;
import android.text.TextUtils;
import android.util.Log;

import com.mpatric.mp3agic.ID3v1Genres;
import com.mpatric.mp3agic.ID3v1Tag;
import com.mpatric.mp3agic.ID3v2;
import com.mpatric.mp3agic.ID3v22Tag;
import com.mpatric.mp3agic.ID3v23Tag;
import com.mpatric.mp3agic.ID3v24Tag;
import com.mpatric.mp3agic.Mp3File;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import de.arcus.framework.logger.Logger;
import de.arcus.framework.superuser.SuperUser;
import de.arcus.framework.superuser.SuperUserTools;
import de.arcus.framework.utils.FileTools;
import de.arcus.playmusiclib.enums.ID3v2Version;
import de.arcus.playmusiclib.exceptions.CouldNotOpenDatabaseException;
import de.arcus.playmusiclib.exceptions.NoSuperUserException;
import de.arcus.playmusiclib.exceptions.PlayMusicNotFoundException;
import de.arcus.playmusiclib.items.MusicTrack;


/**
 * Connects to the PlayMusic data
 */
public class PlayMusicManager {
    /**
     * PlayMusic package id
     */
    public static final String PLAYMUSIC_PACKAGE_ID = "com.google.android.music";

    /**
     * The last created instance
     */
    private static PlayMusicManager instance;

    /**
     * @return Gets the last created instance or returns null if there is no instance
     */
    public static PlayMusicManager getInstance() {
        return instance;
    }

    /**
     * Context of the app, needed to access to the package manager
     */
    private Context mContext;

    /**
     * @return Gets the app context
     */
    public Context getContext() {
        return mContext;
    }

    /**
     * Play Music database
     */
    private SQLiteDatabase mDatabase;

    /**
     * @return Gets the database
     */
    public SQLiteDatabase getDatabase() {
        return mDatabase;
    }

    /**
     * Path to the private app data
     * Eg.: /data/data/com.google.android.music/
     */
    private String mPathPrivateData;

    /**
     * Paths to all possible public app data
     * Eg.: /sdcard/Android/data/com.google.android.music/
     */
    private String[] mPathPublicData;

    /**
     * Application info from PlayMusic
     */
    private ApplicationInfo mPlayMusicApplicationInfo;

    /**
     * @return Gets the path to the database
     */
    private String getDatabasePath() {
        return mPathPrivateData + "/databases/music.db";
    }

    /**
     * The database will be copied to a temp folder to access from the app
     * @return Gets the temp path to the database
     */
    private String getTempDatabasePath() {
        return getTempPath() + "music.db";
    }

    /**
     * @return Gets the temp path to the exported music
     */
    private String getTempPath() {
        // Marshmallow hack
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            // Use the internal storage instead
            String path = Environment.getExternalStorageDirectory() + "/PlayMusicExporter/";
            FileTools.directoryCreate(path);
            return path;
        } else {
            return mContext.getCacheDir().getAbsolutePath();
        }
    }

    /**
     * If this is set the data source will only load offline tracks
     */
    private boolean mOfflineOnly;

    /**
     * @return Returns whether the data source should only load offline tracks
     */
    public boolean getOfflineOnly() {
        return mOfflineOnly;
    }

    /**
     * @param offlineOnly Sets whether the data source should only load offline tracks
     */
    public void setOfflineOnly(boolean offlineOnly) {
        mOfflineOnly = offlineOnly;
    }

    /**
     * If this is set the exporter will add ID3 tag to the mp3 files
     */
    private boolean mID3Enable = true;

    /**
     * @return Gets whether the exporter adds ID3 tags to the mp3 files
     */
    public boolean getID3Enable() {
        return mID3Enable;
    }

    /**
     * @param id3Enable Sets whether the exporter adds ID3 tags to the mp3 files
     */
    public void setID3Enable(boolean id3Enable) {
        mID3Enable = id3Enable;
    }

    /**
     * If this is set the exporter will add the artwork to the ID2v2 tag
     */
    private boolean mID3EnableArtwork = true;

    /**
     * @return Gets whether the exporter adds the artwork image
     */
    public boolean getID3EnableArtwork() {
        return mID3EnableArtwork;
    }

    /**
     * @param id3EnableArtwork Sets whether the exporter adds the artwork image
     */
    public void setID3EnableArtwork(boolean id3EnableArtwork) {
        mID3EnableArtwork = id3EnableArtwork;
    }

    /**
     * The ID3 artwork format (eg. JPEG or PNG)
     */
    private Bitmap.CompressFormat mID3ArtworkFormat = Bitmap.CompressFormat.JPEG;

    /**
     * @return Gets the current artwork format
     */
    public Bitmap.CompressFormat getID3ArtworkFormat() {
        return mID3ArtworkFormat;
    }

    /**
     * @param id3ArtworkFormat Sets the artwork format for the id3 tag
     */
    public void setID3ArtworkFormat(Bitmap.CompressFormat id3ArtworkFormat) {
        mID3ArtworkFormat = id3ArtworkFormat;
    }

    /**
     * The ID3 artwork maximum size (0 = use original size)
     */
    private int mID3ArtworkMaximumSize = 512;

    /**
     * @return Gets the current artwork format
     */
    public int getID3ArtworkMaximumSize() {
        return mID3ArtworkMaximumSize;
    }

    /**
     * @param id3ArtworkMaximumSize Sets the artwork maximum size of the artwork.
     *                              If the original artwork is larger than this value the app will
     *                              sample it down. (0 = use original size)
     */
    public void setID3ArtworkMaximumSize(int id3ArtworkMaximumSize) {
        mID3ArtworkMaximumSize = id3ArtworkMaximumSize;
    }

    /**
     * If this is set the exporter will also adds ID3v1 tags
     */
    private boolean mID3EnableFallback = true;

    /**
     * @return Gets whether the exporter adds ID3v1 tags as fallback
     */
    public boolean getID3EnableFallback() {
        return mID3EnableFallback;
    }

    /**
     * @param id3EnableFallback Sets whether the exporter adds ID3v1 tags as fallback
     */
    public void setID3EnableFallback(boolean id3EnableFallback) {
        mID3EnableFallback = id3EnableFallback;
    }

    /**
     * The sub version of ID3v2
     * Use 2.3 for default to fix issues with the Windows Windows Media Player
     */
    private ID3v2Version mID3v2Version = ID3v2Version.ID3v23;

    /**
     * @return Gets the sub version of ID3v2
     */
    public ID3v2Version getID3v2Version() {
        return mID3v2Version;
    }

    /**
     * @param id3v2Version Sets the sub version of ID3v2
     */
    public void setID3v2Version(ID3v2Version id3v2Version) {
        mID3v2Version = id3v2Version;
    }

    /**
     * Creates a new PlayMusic manager
     * @param context App context
     */
    public PlayMusicManager(Context context) {
        mContext = context;
        instance = this;
    }


    /**
     * Loads all needed information and opens the database
     * @throws PlayMusicNotFoundException PlayMusic is not installed
     * @throws NoSuperUserException No super user permissions
     * @throws CouldNotOpenDatabaseException Could not open the database
     */
    public void startUp() throws PlayMusicNotFoundException, NoSuperUserException, CouldNotOpenDatabaseException {
        // Gets the package manager
        PackageManager packageManager = mContext.getPackageManager();

        try {
            // Loads the application info
            mPlayMusicApplicationInfo = packageManager.getApplicationInfo(PLAYMUSIC_PACKAGE_ID, 0);
        } catch (PackageManager.NameNotFoundException e) {
            // No PlayMusic
            throw new PlayMusicNotFoundException();
        }


        // Path to the private data
        mPathPrivateData = mPlayMusicApplicationInfo.dataDir;

        List<String> publicDataList = new ArrayList<>();
        // Search on all sdcards
        for (String storage : FileTools.getStorages()) {
            String publicData = storage + "/Android/data/com.google.android.music";

            // Directory exists
            if (FileTools.directoryExists(publicData))
                publicDataList.add(publicData);
        }
        // Convert to array
        mPathPublicData = publicDataList.toArray(new String[publicDataList.size()]);

        // Loads the database
        loadDatabase();
    }

    /**
     * Copies the database to a temp directory and opens it
     * @throws NoSuperUserException No super user permissions
     * @throws de.arcus.playmusiclib.exceptions.CouldNotOpenDatabaseException Could not open the database
     */
    private void loadDatabase() throws NoSuperUserException, CouldNotOpenDatabaseException {
        // Ask for super user
        if (!SuperUser.askForPermissions())
            throw new NoSuperUserException();

        // Close the database
        closeDatabase();

        // Copy the database to the temp folder
        if (!SuperUserTools.fileCopy(getDatabasePath(), getTempDatabasePath()))
            throw new CouldNotOpenDatabaseException();

        // Opens the database
        try {
            mDatabase = SQLiteDatabase.openDatabase(getTempDatabasePath(), null, SQLiteDatabase.OPEN_READONLY);
        } catch (SQLException e) {
            throw new CouldNotOpenDatabaseException();
        }
    }

    /**
     * Reloads the database from PlayMusic
     * @throws NoSuperUserException No super user permissions
     * @throws CouldNotOpenDatabaseException Could not open the database
     */
    public void realoadDatabase() throws NoSuperUserException, CouldNotOpenDatabaseException {
        // Reload database
        loadDatabase();
    }

    /**
     * Closes the database if it's open
     */
    private void closeDatabase() {
        if (mDatabase == null) return;

        mDatabase.close();
    }

    /**
     * Debug function to get the database
     */
    public void copyDatabaseToSdCard() {
        FileTools.fileCopy(getTempDatabasePath(), Environment.getExternalStorageDirectory() + "/music.db");
    }

    /**
     * @return Gets the path to the private music
     */
    public String getPrivateMusicPath() {
        return mPathPrivateData + "/files/music";
    }

    /**
     * Gets the path to the music track
     * @param localCopyPath The local copy path
     * @return The path to the music file
     */
    public String getMusicFile(String localCopyPath) {
        // LocalCopyPath is empty
        if (TextUtils.isEmpty(localCopyPath)) return null;

        String path;

        // Search in the public data
        for (String publicData : mPathPublicData) {
            path = publicData + "/files/music/" + localCopyPath;

            if (FileTools.fileExists(path)) return path;
        }


        // Private music path
        path = getPrivateMusicPath() + "/" + localCopyPath;
        // Don't check if the file exists, this will freeze the UI thread
        //if (SuperUserTools.fileExists(path)) return path;

        return path;
    }

    /**
     * @return Gets the path to the private files
     */
    public String getPrivateFilesPath() {
        return mPathPrivateData + "/files";
    }

    /**
     * Gets the full path to the artwork
     * @param artworkPath The artwork path
     * @return The full path to the artwork
     */
    public String getArtworkPath(String artworkPath) {
        // Artwork path is empty
        if (TextUtils.isEmpty(artworkPath)) return null;

        String path;

        // Fix the path for Play Music 5.9.1854
        if (!artworkPath.startsWith("artwork/"))
            artworkPath = "artwork/" + artworkPath;

        // Search in the public data
        for (String publicData : mPathPublicData) {
            path = publicData + "/files/" + artworkPath;

            if (FileTools.fileExists(path)) return path;
        }

        // Private artwork path
        path = getPrivateFilesPath() + "/" + artworkPath;

        // Don't check if the file exists, this will freeze the UI thread
        // if (SuperUserTools.fileExists(path)) return path;

        return path;
    }


    /**
     * Exports a track to the sd card
     * @param musicTrack The music track you want to export
     * @param dest The destination path
	 * @param forceOverwrite Forces overwrite of the destination file
     * @return Returns whether the export was successful
     */
    public boolean exportMusicTrack(MusicTrack musicTrack, String dest, boolean forceOverwrite ) {
        // Creates the destination directory
        File directory = new File(dest).getParentFile();


        // Filename
        String filename = new File(dest).getName();

        return exportMusicTrack(musicTrack, Uri.fromFile(directory), filename, forceOverwrite);
    }

    /**
     * Exports a track to the sd card
     * @param musicTrack The music track you want to export
     * @param uri The document tree
	 * @param forceOverwrite Forces overwrite of the destination file
     * @return Returns whether the export was successful
     */
    public boolean exportMusicTrack(MusicTrack musicTrack, Uri uri, String path, boolean forceOverwrite) {

        // Check for null
        if (musicTrack == null) return false;

        String srcFile = musicTrack.getSourceFile();

        // Could not find the source file
        if (srcFile == null) return false;

        String uniqueID = UUID.randomUUID().toString();

        if ( forceOverwrite || !isAlreadyThere(uri, path) )
        {

            String fileTmp = getTempPath()  + uniqueID +"_tmp.mp3";

            // Copy to temp path failed
            if (!SuperUserTools.fileCopy(srcFile, fileTmp))
                return false;

            // Encrypt the file
            if (musicTrack.isEncoded()) {
                String fileTmpCrypt = getTempPath()  + uniqueID +"_crypt.mp3";

                // Encrypts the file
                if (trackEncrypt(musicTrack, fileTmp, fileTmpCrypt)) {
                    // Remove the old tmp file
                    FileTools.fileDelete(fileTmp);

                    // New tmp file
                    fileTmp = fileTmpCrypt;
                } else {
                    Logger.getInstance().logWarning("ExportMusicTrack", "Encrypting failed! Continue with decrypted file.");
                }
            }



            String dest;
            Uri copyUri = null;
            if (uri.toString().startsWith("file://")) {
                // Build the full path
                dest = uri.buildUpon().appendPath(path).build().getPath();

                String parentDirectory = new File(dest).getParent();
                FileTools.directoryCreate(parentDirectory);
            } else {
                // Complex uri (Lollipop)
                dest = getTempPath()  + uniqueID +"_final.mp3";

                // The root
                DocumentFile document = DocumentFile.fromTreeUri(mContext, uri);

                // Creates the subdirectories
                String[] directories = path.split("\\/");
                for(int i=0; i<directories.length - 1; i++) {
                    String directoryName = directories[i];
                    boolean found = false;

                    // Search all sub elements
                    for (DocumentFile subDocument:  document.listFiles()) {
                        // Directory exists
                        if (subDocument.isDirectory() && subDocument.getName().equalsIgnoreCase(directoryName)) {
                            document = subDocument;
                            found = true;
                            break;
                        }
                    }

                    if (!found) {
                        // Create the directory
                        document = document.createDirectory(directoryName);
                    }
                }

                // Gets the filename
                String filename = directories[directories.length - 1];

                for (DocumentFile subDocument: document.listFiles()) {
                    // Directory exists
                    if (subDocument.isFile() ){
                        if ( filename != null && subDocument.getName().equalsIgnoreCase(filename)) {
                            // Delete the file
                            if ( forceOverwrite ) {
                                Logger.getInstance().logWarning("ExportMusicTrack", "(forceOverwrite)  Deleting original file: " + filename);
                            }
                            subDocument.delete();
                            break;
                        }
                    }
                }

                // Create the mp3 file
                document = document.createFile("music/mp3", filename);

                // Create the directories
                copyUri = document.getUri();
            }


            // We want to export the ID3 tags
            if (mID3Enable) {
                // Adds the meta data
                if (!trackWriteID3(musicTrack, fileTmp, dest)) {
                    Logger.getInstance().logWarning("ExportMusicTrack", "ID3 writer failed! Continue without ID3 tags.");

                    // Failed, moving without meta data
                    if (!FileTools.fileMove(fileTmp, dest)) {
                        Logger.getInstance().logError("ExportMusicTrack", "Moving the raw file failed!");

                        // Could not copy the file
                        return false;
                    }
                }
            } else {
                // Moving the file
                if (!FileTools.fileMove(fileTmp, dest)) {
                    Logger.getInstance().logError("ExportMusicTrack", "Moving the raw file failed!");

                    // Could not copy the file
                    return false;
                }
            }

            // We need to copy the file to a uri
            if (copyUri != null) {
                // Lollipop only
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                    try {
                        // Gets the file descriptor
                        ParcelFileDescriptor parcelFileDescriptor = mContext.getContentResolver().openFileDescriptor(copyUri, "w");

                        // Gets the output stream
                        FileOutputStream fileOutputStream = new FileOutputStream(parcelFileDescriptor.getFileDescriptor());

                        // Gets the input stream
                        FileInputStream fileInputStream = new FileInputStream(dest);

                        // Copy the stream
                        FileTools.fileCopy(fileInputStream, fileOutputStream);

                        // Close all streams
                        fileOutputStream.close();
                        fileInputStream.close();
                        parcelFileDescriptor.close();

                    } catch (FileNotFoundException e) {
                        Logger.getInstance().logError("ExportMusicTrack", "File not found!");

                        // Could not copy the file
                        return false;
                    } catch (IOException e) {
                        Logger.getInstance().logError("ExportMusicTrack", "Failed to write the document: " + e.toString());

                        // Could not copy the file
                        return false;
                    }
                }
            }

            // Delete temp files
            cleanUp(uniqueID);

            // Adds the file to the media system
            //new MediaScanner(mContext, dest);

        } else {
            Logger.getInstance().logInfo("exportMusicTrack", path + " already exists, skipping." );
        }

        // Done
        return true;
    }

    /**
     * Checks if the destination file already exists
     * @param pUri the source file
     * @param pPath The destination
     * return true if the file already exists
     */
    private boolean isAlreadyThere(Uri pUri, String pPath) {
        if (pUri.toString().startsWith("file://")) {
            //Old sdcard URI
            return FileTools.fileExists(pUri.buildUpon().appendPath(pPath).build().toString());
        } else {
            //Documents Provider URI
            DocumentFile lDocumentFile = DocumentFile.fromTreeUri(mContext, pUri);
            for (String lDisplayName : pPath.split("/")) {
                if (lDocumentFile.findFile(lDisplayName) != null) {
                    lDocumentFile = lDocumentFile.findFile(lDisplayName);
                    if ( lDocumentFile.length() == 0 ) {
                        if ( !lDocumentFile.isDirectory() ) {
                            Logger.getInstance().logInfo("isAlreadyThere", pPath + " File exists, but is 0 bytes in size.");
                        }
                    }
                } else {
                    Logger.getInstance().logInfo("isAlreadyThere", pPath + " does not exist yet.");
                    return false;
                }
            }
            return true;
        }
    }

    /**
     * Copies the music file to a new path and adds the mp3 meta data
     * @param musicTrack Track information
     * @param src The source mp3 file
     * @param dest The destination path
     * return Return if the operation was successful
     */
    private boolean trackWriteID3(MusicTrack musicTrack, String src, String dest) {
        try {
            // Opens the mp3
            Mp3File mp3File = new Mp3File(src);

            // Removes all existing tags
            mp3File.removeId3v1Tag();
            mp3File.removeId3v2Tag();
            mp3File.removeCustomTag();

            // We want to add a fallback ID3v1 tag
            if (mID3EnableFallback) {
                // Create a new tag with ID3v1
                ID3v1Tag tagID3v1 = new ID3v1Tag();

                // Set all tag values
                tagID3v1.setTrack(musicTrack.getTitle());
                tagID3v1.setArtist(musicTrack.getArtist());
                tagID3v1.setAlbum(musicTrack.getAlbum());
                tagID3v1.setYear(musicTrack.getYear());

                // Search the genre
                for(int n=0; n<ID3v1Genres.GENRES.length; n++) {
                    // Genre found
                    if (ID3v1Genres.GENRES[n].equals(musicTrack.getGenre())) {
                        tagID3v1.setGenre(n);
                        break;
                    }
                }

                mp3File.setId3v1Tag(tagID3v1);
            }

            // It can't be null
            final ID3v2 tagID3v2;

            // Creates the requested version
            switch(mID3v2Version) {
                case ID3v22:
                    tagID3v2 = new ID3v22Tag();
                    break;
                case ID3v23:
                    tagID3v2 = new ID3v23Tag();
                    break;
                case ID3v24:
                    tagID3v2 = new ID3v24Tag();
                    break;
                default:
                    tagID3v2 = null;
                    break;
            }


            // Set all tag values
            tagID3v2.setTitle(musicTrack.getTitle());
            tagID3v2.setArtist(musicTrack.getArtist());
            tagID3v2.setAlbum(musicTrack.getAlbum());
            tagID3v2.setAlbumArtist(musicTrack.getAlbumArtist());
            tagID3v2.setTrack("" + musicTrack.getTrackNumber());
            tagID3v2.setPartOfSet("" + musicTrack.getDiscNumber());
            tagID3v2.setYear(musicTrack.getYear());

            if (!TextUtils.isEmpty(musicTrack.getGenre())) {
                try {
                    // Maybe the genre is not supported
                    tagID3v2.setGenreDescription(musicTrack.getGenre());
                } catch (IllegalArgumentException e) {
                    Logger.getInstance().logWarning("TrackWriteID3", e.getMessage());
                }
            }

            // Add the artwork to the meta data
            if (mID3EnableArtwork) {
                // Load the artwork
                Bitmap bitmap = ArtworkLoader.loadArtwork(musicTrack, mID3ArtworkMaximumSize);

                if (bitmap != null) {
                    // JPEG is default
                    String mimeType = "image/jpeg";

                    // Load the bitmap into a byte array
                    ByteArrayOutputStream artworkDataStream = new ByteArrayOutputStream();
                    bitmap.compress(Bitmap.CompressFormat.JPEG, 90, artworkDataStream);

                    // Adds the artwork to the meta data
                    tagID3v2.setAlbumImage(artworkDataStream.toByteArray(), mimeType);
                }
            }

            mp3File.setId3v2Tag(tagID3v2);


            // Save the file
            mp3File.save(dest);


            // Done
            return true;
        } catch (Exception e) {
            Logger.getInstance().logError("TrackWriteId3", e.toString());
        }

        // Failed
        return false;
    }

    /**
     * Encrypts a track and save it to a new path
     * @param musicTrack The music track
     * @param src The source mp3 file
     * @param dest The destination path
     * @return Return if the operation was successful
     */
    private boolean trackEncrypt(MusicTrack musicTrack, String src, String dest) {

        try {
            AllAccessExporter allAccessExporter = new AllAccessExporter(src, musicTrack.getCpData());

            // Checks the magic number
            if (!allAccessExporter.hasValidMagicNumber()) {
                Logger.getInstance().logError("TrackEncrypt", "Invalid magic number! This is not an AllAccess file");
                return false;
            }

            // Saves the file
            return allAccessExporter.save(dest);
        } catch (Exception e) {
            Logger.getInstance().logError("TrackEncrypt", e.toString());
        }

        // Failed
        return false;
    }


    /**
     * Deletes all cache files
     */
    private void cleanUp(String theUniqueID) {
        FileTools.fileDelete( getTempPath() + theUniqueID +"_final.mp3");
        FileTools.fileDelete( getTempPath() +  theUniqueID +"_tmp.mp3");
        FileTools.fileDelete( getTempPath() +  theUniqueID +"_crypt.mp3");
    }
}