/*
 * Copyright (c) 2010-2019 Belledonne Communications SARL.
 *
 * This file is part of linphone-android
 * (see https://www.linphone.org).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
package org.linphone.utils;

import android.annotation.SuppressLint;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore;
import android.provider.OpenableColumns;
import android.text.TextUtils;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import org.linphone.LinphoneManager;
import org.linphone.core.Address;
import org.linphone.core.Friend;
import org.linphone.core.FriendList;
import org.linphone.core.tools.Log;

public class FileUtils {
    public static String getNameFromFilePath(String filePath) {
        if (filePath == null) return null;

        String name = filePath;
        int i = filePath.lastIndexOf('/');
        if (i > 0) {
            name = filePath.substring(i + 1);
        }
        return name;
    }

    public static String getExtensionFromFileName(String fileName) {
        if (fileName == null) return null;

        String extension = null;
        int i = fileName.lastIndexOf('.');
        if (i > 0) {
            extension = fileName.substring(i + 1);
        }
        return extension;
    }

    public static Boolean isExtensionImage(String path) {
        String extension = getExtensionFromFileName(path);
        if (extension != null) extension = extension.toLowerCase();
        return (extension != null && extension.matches("(png|jpg|jpeg|bmp|gif)"));
    }

    public static String getFilePath(final Context context, final Uri uri) {
        if (uri == null) return null;

        String result = null;
        String name = getNameFromUri(uri, context);

        try {
            File localFile = createFile(context, name);
            InputStream remoteFile = context.getContentResolver().openInputStream(uri);
            Log.i(
                    "[File Utils] Trying to copy file from "
                            + uri.toString()
                            + " to local file "
                            + localFile.getAbsolutePath());

            if (copyToFile(remoteFile, localFile)) {
                Log.i("[File Utils] Copy successful");
                result = localFile.getAbsolutePath();
            } else {
                Log.e("[File Utils] Copy failed");
            }

            remoteFile.close();
        } catch (IOException e) {
            Log.e("[File Utils] getFilePath exception: ", e);
        }

        return result;
    }

    private static String getNameFromUri(Uri uri, Context context) {
        String name = null;
        if (uri != null) {
            if (uri.getScheme().equals("content")) {
                Cursor returnCursor =
                        context.getContentResolver().query(uri, null, null, null, null);
                if (returnCursor != null) {
                    returnCursor.moveToFirst();
                    int nameIndex = returnCursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
                    name = returnCursor.getString(nameIndex);
                    returnCursor.close();
                }
            } else if (uri.getScheme().equals("file")) {
                name = uri.getLastPathSegment();
            }
        }
        return name;
    }

    /**
     * Copy data from a source stream to destFile. Return true if succeed, return false if failed.
     */
    private static boolean copyToFile(InputStream inputStream, File destFile) {
        if (inputStream == null || destFile == null) return false;
        try {
            try (OutputStream out = new FileOutputStream(destFile)) {
                byte[] buffer = new byte[4096];
                int bytesRead;
                while ((bytesRead = inputStream.read(buffer)) >= 0) {
                    out.write(buffer, 0, bytesRead);
                }
            }
            return true;
        } catch (IOException e) {
            Log.e("[File Utils] copyToFile exception: " + e);
        }
        return false;
    }

    private static File createFile(Context context, String fileName) {
        if (fileName == null) return null;
        if (TextUtils.isEmpty(fileName)) fileName = getStartDate();

        if (!fileName.contains(".")) {
            fileName = fileName + ".unknown";
        }

        final File root;
        root = context.getExternalCacheDir();

        if (root != null && !root.exists()) {
            boolean result = root.mkdirs();
            if (!result) {
                Log.e("[File Utils] Couldn't create directory " + root.getAbsolutePath());
            }
        }
        return new File(root, fileName);
    }

    public static Uri getCVSPathFromLookupUri(String content) {
        if (content == null) return null;

        String contactId = getNameFromFilePath(content);
        FriendList[] friendList = LinphoneManager.getCore().getFriendsLists();
        for (FriendList list : friendList) {
            for (Friend friend : list.getFriends()) {
                if (friend.getRefKey().equals(contactId)) {
                    String contactVcard = friend.getVcard().asVcard4String();
                    return createCvsFromString(contactVcard);
                }
            }
        }
        return null;
    }

    public static String getRealPathFromURI(Context context, Uri contentUri) {
        String[] proj = {MediaStore.Images.Media.DATA};
        Cursor cursor = context.getContentResolver().query(contentUri, proj, null, null, null);
        if (cursor != null && cursor.moveToFirst()) {
            int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            String result = cursor.getString(column_index);
            cursor.close();
            return result;
        }
        return null;
    }

    public static void deleteFile(String filePath) {
        if (filePath == null || filePath.isEmpty()) return;
        File file = new File(filePath);
        if (file.exists()) {
            try {
                if (file.delete()) {
                    Log.i("[File Utils] File deleted: ", filePath);
                } else {
                    Log.e("[File Utils] Can't delete ", filePath);
                }
            } catch (Exception e) {
                Log.e("[File Utils] Can't delete ", filePath, ", exception: ", e);
            }
        } else {
            Log.e("[File Utils] File ", filePath, " doesn't exists");
        }
    }

    public static String getStorageDirectory(Context mContext) {
        File path = null;
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            Log.w("[File Utils] External storage is mounted");
            String directory = Environment.DIRECTORY_DOWNLOADS;
            path = mContext.getExternalFilesDir(directory);
        }

        if (path == null) {
            Log.w("[File Utils] Couldn't get external storage path, using internal");
            path = mContext.getFilesDir();
        }

        return path.getAbsolutePath();
    }

    public static String getRecordingsDirectory(Context mContext) {
        return getStorageDirectory(mContext);
    }

    @SuppressLint("SimpleDateFormat")
    public static String getCallRecordingFilename(Context context, Address address) {
        String fileName = getRecordingsDirectory(context) + "/";

        String name =
                address.getDisplayName() == null ? address.getUsername() : address.getDisplayName();
        fileName += name + "_";

        DateFormat format = new SimpleDateFormat("dd-MM-yyyy-HH-mm-ss");
        fileName += format.format(new Date()) + ".mkv";

        return fileName;
    }

    private static Uri createCvsFromString(String vcardString) {
        String contactName = getContactNameFromVcard(vcardString);
        File vcfFile = new File(Environment.getExternalStorageDirectory(), contactName + ".cvs");
        try {
            FileWriter fw = new FileWriter(vcfFile);
            fw.write(vcardString);
            fw.close();
            return Uri.fromFile(vcfFile);
        } catch (IOException e) {
            Log.e("[File Utils] createCVSFromString exception: " + e);
        }
        return null;
    }

    private static String getContactNameFromVcard(String vcard) {
        if (vcard != null) {
            String contactName = vcard.substring(vcard.indexOf("FN:") + 3);
            contactName = contactName.substring(0, contactName.indexOf("\n") - 1);
            contactName = contactName.replace(";", "");
            contactName = contactName.replace(" ", "");
            return contactName;
        }
        return null;
    }

    private static String getStartDate() {
        try {
            return new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.ROOT).format(new Date());
        } catch (RuntimeException e) {
            return new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(new Date());
        }
    }

    public static String getMimeFromFile(String path) {
        if (isExtensionImage(path)) {
            return "image/" + getExtensionFromFileName(path);
        }
        return "file/" + getExtensionFromFileName(path);
    }
}