FairEmail/app/src/main/java/eu/faircode/email/EntityAttachment.java

package eu.faircode.email;

/*
    This file is part of FairEmail.

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

    FairEmail 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 FairEmail.  If not, see <http://www.gnu.org/licenses/>.

    Copyright 2018-2024 by Marcel Bokhorst (M66B)
*/

import static androidx.room.ForeignKey.CASCADE;

import android.content.Context;
import android.content.SharedPreferences;
import android.net.Uri;
import android.text.TextUtils;

import androidx.annotation.NonNull;
import androidx.preference.PreferenceManager;
import androidx.room.Entity;
import androidx.room.ForeignKey;
import androidx.room.Ignore;
import androidx.room.Index;
import androidx.room.PrimaryKey;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.zip.Deflater;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import javax.mail.Part;

@Entity(
        tableName = EntityAttachment.TABLE_NAME,
        foreignKeys = {
                @ForeignKey(childColumns = "message", entity = EntityMessage.class, parentColumns = "id", onDelete = CASCADE)
        },
        indices = {
                @Index(value = {"message"}),
                @Index(value = {"message", "sequence", "subsequence"}, unique = true),
                @Index(value = {"message", "cid"})
        }
)
public class EntityAttachment {
    static final String TABLE_NAME = "attachment";

    static final Integer PGP_MESSAGE = 1;
    static final Integer PGP_SIGNATURE = 2;
    static final Integer PGP_KEY = 3;
    static final Integer PGP_CONTENT = 4;
    static final Integer SMIME_MESSAGE = 5;
    static final Integer SMIME_SIGNATURE = 6;
    static final Integer SMIME_SIGNED_DATA = 7;
    static final Integer SMIME_CONTENT = 8;

    static final String VCARD_PREFIX = BuildConfig.APPLICATION_ID + ".vcard.";

    @PrimaryKey(autoGenerate = true)
    public Long id;
    public String section;
    @NonNull
    public Long message;
    @NonNull
    public Integer sequence;
    public Integer subsequence; // embedded messages
    public String name;
    @NonNull
    public String type;
    public String disposition;
    public String cid; // Content-ID
    public Boolean related; // inline
    public Integer encryption;
    public Long size;
    public Integer progress;
    @NonNull
    public Boolean available = false;
    public String media_uri;
    public String error;

    @Ignore
    public boolean selected = false;

    // Gmail sends inline images as attachments with a name and cid

    boolean isInline() {
        return (Part.INLINE.equals(disposition) ||
                (!Boolean.FALSE.equals(related) && cid != null));
    }

    boolean isAttachment() {
        return (Part.ATTACHMENT.equals(disposition) || !TextUtils.isEmpty(name));
    }

    boolean isImage() {
        return ImageHelper.isImage(getMimeType());
    }

    boolean isVideo() {
        String type = getMimeType();
        return (type != null && type.startsWith("video/"));
    }

    boolean isAudio() {
        String type = getMimeType();
        return (type != null && type.startsWith("audio/"));
    }

    boolean isPDF() {
        return "application/pdf".equals(getMimeType());
    }

    boolean isCompressed() {
        if ("application/zip".equals(type))
            return true;
        if ("application/gzip".equals(type))
            return true;

        String extension = Helper.getExtension(name);
        if ("zip".equals(extension))
            return true;
        if ("gz".equals(extension))
            return true;

        return false;
    }

    boolean isGzip() {
        if ("application/gzip".equals(type))
            return true;

        String extension = Helper.getExtension(name);
        if ("gz".equals(extension))
            return true;

        return false;
    }

    boolean isTarGzip() {
        return (name != null && name.endsWith(".tar.gz"));
    }

    boolean isEncryption() {
        if ("application/pkcs7-mime".equals(type))
            return true;
        if ("application/x-pkcs7-mime".equals(type))
            return true;
        if ("application/pkcs7-signature".equals(type))
            return true;
        if ("application/x-pkcs7-signature".equals(type))
            return true;
        return (encryption != null);
    }

    Uri getUri(Context context) {
        File file = getFile(context);
        return FileProviderEx.getUri(context, BuildConfig.APPLICATION_ID, file, name);
    }

    File getFile(Context context) {
        return getFile(context, id, name);
    }

    static File getFile(Context context, long id, String name) {
        File dir = getRoot(context);
        String filename = Long.toString(id);
        if (!TextUtils.isEmpty(name))
            filename += "." + Helper.sanitizeFilename(name);
        if (filename.length() > 127)
            filename = filename.substring(0, 127);
        return new File(dir, filename);
    }

    static File getRoot(Context context) {
        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
        boolean external_storage = prefs.getBoolean("external_storage", false);

        if (external_storage) {
            File dir = new File(Helper.getExternalFilesDir(context), "attachments");
            dir.mkdirs();
            return dir;
        }

        return Helper.ensureExists(context, "attachments");
    }

    static void copy(Context context, long oldid, long newid) {
        DB db = DB.getInstance(context);

        List<EntityAttachment> attachments = db.attachment().getAttachments(oldid);
        for (EntityAttachment attachment : attachments) {
            File source = attachment.getFile(context);

            attachment.id = null;
            attachment.message = newid;
            attachment.progress = null;
            attachment.id = db.attachment().insertAttachment(attachment);

            if (attachment.available) {
                File target = attachment.getFile(context);
                try {
                    Helper.copy(source, target);
                } catch (IOException ex) {
                    Log.e(ex);
                    db.attachment().setError(attachment.id, Log.formatThrowable(ex, false));
                }
            }
        }
    }

    String getMimeType() {
        // Try to guess a better content type
        // For example, sometimes PDF files are sent as application/octet-stream

        // https://android.googlesource.com/platform/libcore/+/refs/tags/android-9.0.0_r49/luni/src/main/java/libcore/net/MimeUtils.java
        // https://docs.microsoft.com/en-us/archive/blogs/vsofficedeveloper/office-2007-file-format-mime-types-for-http-content-streaming-2

        if (encryption != null)
            return type;

        if ("audio/mid".equals(type))
            return "audio/midi";

        if ("audio/x-wav".equals(type) ||
                "audio-x/wav".equals(type))
            return "audio/wav";

        // https://www.rfc-editor.org/rfc/rfc3555.txt
        if ("image/jpg".equals(type) || "video/jpeg".equals(type))
            return "image/jpeg";

        if (!TextUtils.isEmpty(type) &&
                (type.endsWith("/pdf") || type.endsWith("/x-pdf")))
            return "application/pdf";

        if ("text/v-calendar".equals(type) ||
                "text/x-vcalendar".equals(type))
            return "text/calendar";

        String extension = Helper.getExtension(name);
        if (extension == null)
            return type;

        String gtype = Helper.guessMimeType(name);
        if (!TextUtils.isEmpty(type) && !type.equals(gtype))
            Log.w("Mime type=" + type + " extension=" + extension + " guessed=" + gtype);

        extension = extension.toLowerCase(Locale.ROOT);

        // Fix types
        if ("csv".equals(extension))
            return "text/csv";

        if ("gpx".equals(extension))
            return "application/gpx+xml";

        // Adobe

        if ("dxf".equals(extension))
            return "application/dxf";

        if ("pdf".equals(extension))
            return "application/pdf";

        // Microsoft

        if ("doc".equals(extension))
            return "application/msword";

        if ("docx".equals(extension))
            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";

        if ("xls".equals(extension))
            return "application/vnd.ms-excel";

        if ("xlsx".equals(extension))
            return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";

        if ("ppt".equals(extension))
            return "application/vnd.ms-powerpoint";

        if ("application/vnd.ms-pps".equals(type))
            return "application/vnd.ms-powerpoint";

        if ("pptx".equals(extension))
            return "application/vnd.openxmlformats-officedocument.presentationml.presentation";

        if ("ppsx".equals(extension))
            return "application/vnd.openxmlformats-officedocument.presentationml.slideshow";

        // OpenOffice

        if ("odt".equals(extension))
            return "application/vnd.oasis.opendocument.text";

        if ("ods".equals(extension))
            return "application/vnd.oasis.opendocument.spreadsheet";

        if ("odp".equals(extension))
            return "application/vnd.oasis.opendocument.presentation";

        // Audio

        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Configuring_servers_for_Ogg_media

        if ("oga".equals(extension))
            return "audio/ogg";

        if ("ogv".equals(extension))
            return "video/ogg";

        if ("ogg".equals(extension))
            return "application/ogg";

        if ("wav".equals(extension))
            return "audio/wav";

        // Images

        if ("avif".equals(extension))
            return "image/avif";

        if ("bmp".equals(extension))
            return "image/bmp";

        if ("heic".equals(extension))
            return "image/heic";

        if ("heif".equals(extension))
            return "image/heif";

        if ("gif".equals(extension))
            return "image/gif";

        if ("jpg".equals(extension) || "jpeg".equals(extension))
            return "image/jpeg";

        if ("png".equals(extension))
            return "image/png";

        if ("svg".equals(extension))
            return "image/svg+xml";

        if ("webp".equals(extension))
            return "image/webp";

        // Other

        if ("zip".equals(extension) ||
                "application/x-zip-compressed".equals(type))
            return "application/zip"; //

        if ("ics".equals(extension) || "vcs".equals(extension))
            return "text/calendar";

        if ("text/plain".equals(type) && "ovpn".equals(extension))
            return "application/x-openvpn-profile";

        // Guess types
        if (gtype != null) {
            if (TextUtils.isEmpty(type) ||
                    "*/*".equals(type) ||
                    type.startsWith("unknown/") ||
                    type.endsWith("/unknown") ||
                    "application/base64".equals(type) ||
                    "application/octet-stream".equals(type) ||
                    "application/x-unknown-content-type".equals(type) ||
                    "application/zip".equals(type))
                return gtype;

            // Some servers erroneously remove dots from mime types
            if (gtype.replace(".", "").equals(type))
                return gtype;
        }

        return type;
    }

    void zip(Context context) throws IOException {
        File file = getFile(context);
        File zip = new File(file.getAbsolutePath() + ".zip");

        try (ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(zip)))) {
            out.setMethod(ZipOutputStream.DEFLATED);
            out.setLevel(Deflater.BEST_COMPRESSION);
            ZipEntry entry = new ZipEntry(name);
            out.putNextEntry(entry);
            try (InputStream in = new BufferedInputStream(new FileInputStream(file))) {
                Helper.copy(in, out);
            }
        }

        DB db = DB.getInstance(context);
        db.attachment().setName(id, name + ".zip", "application/zip", zip.length());
        db.attachment().setDownloaded(id, zip.length());
        Helper.secureDelete(file);
    }

    void zip(Context context, File[] files) throws IOException {
        File file = getFile(context);
        File zip = new File(file.getAbsolutePath() + ".zip");

        try (ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(zip)))) {
            out.setMethod(ZipOutputStream.DEFLATED);
            out.setLevel(Deflater.BEST_COMPRESSION);
            for (File f : files) {
                ZipEntry entry = new ZipEntry(f.getName());
                out.putNextEntry(entry);
                try (InputStream in = new BufferedInputStream(new FileInputStream(f))) {
                    Helper.copy(in, out);
                }
            }
        }

        DB db = DB.getInstance(context);
        db.attachment().setName(id, name + ".zip", "application/zip", zip.length());
        db.attachment().setDownloaded(id, zip.length());
        Helper.secureDelete(file);
    }

    public static boolean equals(List<EntityAttachment> a1, List<EntityAttachment> a2) {
        if (a1 == null || a2 == null)
            return false;

        List<EntityAttachment> list = new ArrayList<>();

        for (EntityAttachment a : a1)
            if (a.available && !a.isEncryption())
                list.add(a);

        for (EntityAttachment a : a2)
            if (a.available && !a.isEncryption()) {
                boolean found = false;
                for (EntityAttachment l : list)
                    if (Objects.equals(a.sequence, l.sequence) &&
                            Objects.equals(a.subsequence, l.subsequence)) {
                        list.remove(l);
                        found = true;
                        break;
                    }
                if (!found)
                    return false;
            }

        return (list.size() == 0);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof EntityAttachment) {
            EntityAttachment other = (EntityAttachment) obj;
            return (Objects.equals(this.section, other.section) &&
                    this.message.equals(other.message) &&
                    this.sequence.equals(other.sequence) &&
                    Objects.equals(this.name, other.name) &&
                    this.type.equals(other.type) &&
                    Objects.equals(this.disposition, other.disposition) &&
                    Objects.equals(this.cid, other.cid) &&
                    Objects.equals(this.encryption, other.encryption) &&
                    Objects.equals(this.size, other.size) &&
                    Objects.equals(this.progress, other.progress) &&
                    this.available.equals(other.available) &&
                    Objects.equals(this.error, other.error));
        } else
            return false;
    }

    @NonNull
    @Override
    public String toString() {
        return (this.name +
                " type=" + this.type +
                " disposition=" + this.disposition +
                " cid=" + this.cid +
                " encryption=" + this.encryption +
                " size=" + this.size);
    }
}