/*
 * 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.notifications;

import static android.content.Context.NOTIFICATION_SERVICE;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.service.notification.StatusBarNotification;
import java.io.File;
import java.util.HashMap;
import org.linphone.LinphoneManager;
import org.linphone.R;
import org.linphone.call.CallActivity;
import org.linphone.call.CallIncomingActivity;
import org.linphone.call.CallOutgoingActivity;
import org.linphone.chat.ChatActivity;
import org.linphone.compatibility.Compatibility;
import org.linphone.contacts.ContactsManager;
import org.linphone.contacts.LinphoneContact;
import org.linphone.core.Address;
import org.linphone.core.Call;
import org.linphone.core.ChatMessage;
import org.linphone.core.ChatMessageListenerStub;
import org.linphone.core.ChatRoom;
import org.linphone.core.ChatRoomCapabilities;
import org.linphone.core.Content;
import org.linphone.core.Core;
import org.linphone.core.CoreListenerStub;
import org.linphone.core.Reason;
import org.linphone.core.tools.Log;
import org.linphone.dialer.DialerActivity;
import org.linphone.history.HistoryActivity;
import org.linphone.service.LinphoneService;
import org.linphone.settings.LinphonePreferences;
import org.linphone.utils.DeviceUtils;
import org.linphone.utils.FileUtils;
import org.linphone.utils.ImageUtils;
import org.linphone.utils.LinphoneUtils;
import org.linphone.utils.MediaScannerListener;

public class NotificationsManager {
    private static final int SERVICE_NOTIF_ID = 1;
    private static final int MISSED_CALLS_NOTIF_ID = 2;

    private final Context mContext;
    private final NotificationManager mNM;
    private final HashMap<String, Notifiable> mChatNotifMap;
    private final HashMap<String, Notifiable> mCallNotifMap;
    private int mLastNotificationId;
    private final Notification mServiceNotification;
    private int mCurrentForegroundServiceNotification;
    private String mCurrentChatRoomAddress;
    private CoreListenerStub mListener;
    private ChatMessageListenerStub mMessageListener;

    public NotificationsManager(Context context) {
        mContext = context;
        mChatNotifMap = new HashMap<>();
        mCallNotifMap = new HashMap<>();
        mCurrentForegroundServiceNotification = 0;
        mCurrentChatRoomAddress = null;

        mNM = (NotificationManager) mContext.getSystemService(NOTIFICATION_SERVICE);

        if (mContext.getResources().getBoolean(R.bool.keep_missed_call_notification_upon_restart)) {
            StatusBarNotification[] notifs = Compatibility.getActiveNotifications(mNM);
            if (notifs != null && notifs.length > 1) {
                for (StatusBarNotification notif : notifs) {
                    if (notif.getId() != MISSED_CALLS_NOTIF_ID) {
                        dismissNotification(notif.getId());
                    }
                }
            }
        } else {
            mNM.cancelAll();
        }

        mLastNotificationId = 5; // Do not conflict with hardcoded notifications ids !

        Compatibility.createNotificationChannels(mContext);

        Bitmap bm = null;
        try {
            bm = BitmapFactory.decodeResource(mContext.getResources(), R.mipmap.ic_launcher);
        } catch (Exception e) {
            Log.e(e);
        }

        Intent notifIntent = new Intent(mContext, DialerActivity.class);
        notifIntent.putExtra("Notification", true);
        addFlagsToIntent(notifIntent);

        PendingIntent pendingIntent =
                PendingIntent.getActivity(
                        mContext, SERVICE_NOTIF_ID, notifIntent, PendingIntent.FLAG_UPDATE_CURRENT);
        mServiceNotification =
                Compatibility.createNotification(
                        mContext,
                        mContext.getString(R.string.service_name),
                        "",
                        R.drawable.linphone_notification_icon,
                        R.mipmap.ic_launcher,
                        bm,
                        pendingIntent,
                        Notification.PRIORITY_MIN,
                        true);

        mListener =
                new CoreListenerStub() {
                    @Override
                    public void onMessageSent(Core core, ChatRoom room, ChatMessage message) {
                        if (room.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) {
                            Compatibility.createChatShortcuts(mContext);
                        }
                    }

                    @Override
                    public void onMessageReceived(
                            Core core, final ChatRoom cr, final ChatMessage message) {
                        if (message.isOutgoing()
                                || mContext.getResources().getBoolean(R.bool.disable_chat)
                                || mContext.getResources()
                                        .getBoolean(R.bool.disable_chat_message_notification)) {
                            return;
                        }

                        if (mCurrentChatRoomAddress != null
                                && mCurrentChatRoomAddress.equals(
                                        cr.getPeerAddress().asStringUriOnly())) {
                            Log.i(
                                    "[Notifications Manager] Message received for currently displayed chat room, do not make a notification");
                            return;
                        }

                        if (message.getErrorInfo() != null
                                && message.getErrorInfo().getReason()
                                        == Reason.UnsupportedContent) {
                            Log.w(
                                    "[Notifications Manager] Message received but content is unsupported, do not notify it");
                            return;
                        }

                        if (!message.hasTextContent()
                                && message.getFileTransferInformation() == null) {
                            Log.w(
                                    "[Notifications Manager] Message has no text or file transfer information to display, ignoring it...");
                            return;
                        }

                        final Address from = message.getFromAddress();
                        final LinphoneContact contact =
                                ContactsManager.getInstance().findContactFromAddress(from);
                        final String textMessage =
                                (message.hasTextContent())
                                        ? message.getTextContent()
                                        : mContext.getString(
                                                R.string.content_description_incoming_file);

                        String file = null;
                        for (Content c : message.getContents()) {
                            if (c.isFile()) {
                                file = c.getFilePath();
                                LinphoneManager.getInstance()
                                        .getMediaScanner()
                                        .scanFile(
                                                new File(file),
                                                new MediaScannerListener() {
                                                    @Override
                                                    public void onMediaScanned(
                                                            String path, Uri uri) {
                                                        createNotification(
                                                                cr,
                                                                contact,
                                                                from,
                                                                textMessage,
                                                                message.getTime(),
                                                                uri,
                                                                FileUtils.getMimeFromFile(path));
                                                    }
                                                });
                                break;
                            }
                        }

                        if (file == null) {
                            createNotification(
                                    cr, contact, from, textMessage, message.getTime(), null, null);
                        }

                        if (cr.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) {
                            Compatibility.createChatShortcuts(mContext);
                        }
                    }
                };

        mMessageListener =
                new ChatMessageListenerStub() {
                    @Override
                    public void onMsgStateChanged(ChatMessage msg, ChatMessage.State state) {
                        if (msg.getUserData() == null) return;
                        int notifId = (int) msg.getUserData();
                        Log.i(
                                "[Notifications Manager] Reply message state changed ("
                                        + state.name()
                                        + ") for notif id "
                                        + notifId);

                        if (state != ChatMessage.State.InProgress) {
                            // There is no need to be called here twice
                            msg.removeListener(this);
                        }

                        if (state == ChatMessage.State.Delivered
                                || state == ChatMessage.State.Displayed) {
                            Notifiable notif =
                                    mChatNotifMap.get(
                                            msg.getChatRoom().getPeerAddress().asStringUriOnly());
                            if (notif == null) {
                                Log.e(
                                        "[Notifications Manager] Couldn't find message notification for SIP URI "
                                                + msg.getChatRoom()
                                                        .getPeerAddress()
                                                        .asStringUriOnly());
                                dismissNotification(notifId);
                                return;
                            } else if (notif.getNotificationId() != notifId) {
                                Log.w(
                                        "[Notifications Manager] Notif ID doesn't match: "
                                                + notifId
                                                + " != "
                                                + notif.getNotificationId());
                            }

                            displayReplyMessageNotification(msg, notif);
                        } else if (state == ChatMessage.State.NotDelivered) {
                            Log.e(
                                    "[Notifications Manager] Couldn't send reply, message is not delivered");
                            dismissNotification(notifId);
                        }
                    }
                };
    }

    public void onCoreReady() {
        Core core = LinphoneManager.getCore();
        if (core != null) {
            core.addListener(mListener);
        }
    }

    public void destroy() {
        // mNM.cancelAll();
        // Don't use cancelAll to keep message notifications !
        // When a message is received by a push, it will create a LinphoneService
        // but it might be getting killed quite quickly after that
        // causing the notification to be missed by the user...
        Log.i("[Notifications Manager] Getting destroyed, clearing Service & Call notifications");

        if (mCurrentForegroundServiceNotification > 0) {
            mNM.cancel(mCurrentForegroundServiceNotification);
        }

        for (Notifiable notifiable : mCallNotifMap.values()) {
            mNM.cancel(notifiable.getNotificationId());
        }

        Core core = LinphoneManager.getCore();
        if (core != null) {
            core.removeListener(mListener);
        }
    }

    private void addFlagsToIntent(Intent intent) {
        intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION | Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
    }

    public void startForeground() {
        if (LinphoneService.isReady()) {
            Log.i("[Notifications Manager] Starting Service as foreground");
            LinphoneService.instance().startForeground(SERVICE_NOTIF_ID, mServiceNotification);
            mCurrentForegroundServiceNotification = SERVICE_NOTIF_ID;
        }
    }

    private void startForeground(Notification notification, int id) {
        if (LinphoneService.isReady()) {
            Log.i("[Notifications Manager] Starting Service as foreground while in call");
            LinphoneService.instance().startForeground(id, notification);
            mCurrentForegroundServiceNotification = id;
        }
    }

    public void stopForeground() {
        if (LinphoneService.isReady()) {
            Log.i("[Notifications Manager] Stopping Service as foreground");
            LinphoneService.instance().stopForeground(true);
            mCurrentForegroundServiceNotification = 0;
        }
    }

    public void removeForegroundServiceNotificationIfPossible() {
        if (LinphoneService.isReady()) {
            if (mCurrentForegroundServiceNotification == SERVICE_NOTIF_ID
                    && !isServiceNotificationDisplayed()) {
                Log.i(
                        "[Notifications Manager] Linphone has started after device boot, stopping Service as foreground");
                stopForeground();
            }
        }
    }

    public void setCurrentlyDisplayedChatRoom(String address) {
        mCurrentChatRoomAddress = address;
        if (address != null) {
            resetMessageNotifCount(address);
        }
    }

    public void dismissMissedCallNotification() {
        dismissNotification(MISSED_CALLS_NOTIF_ID);
    }

    public void sendNotification(int id, Notification notif) {
        Log.i("[Notifications Manager] Notifying " + id);
        mNM.notify(id, notif);
    }

    public void dismissNotification(int notifId) {
        Log.i("[Notifications Manager] Dismissing " + notifId);
        mNM.cancel(notifId);
    }

    public void resetMessageNotifCount(String address) {
        Notifiable notif = mChatNotifMap.get(address);
        if (notif != null) {
            notif.resetMessages();
            mNM.cancel(notif.getNotificationId());
        }
    }

    public ChatMessageListenerStub getMessageListener() {
        return mMessageListener;
    }

    private boolean isServiceNotificationDisplayed() {
        return LinphonePreferences.instance().getServiceNotificationVisibility();
    }

    public String getSipUriForNotificationId(int notificationId) {
        for (String addr : mChatNotifMap.keySet()) {
            if (mChatNotifMap.get(addr).getNotificationId() == notificationId) {
                return addr;
            }
        }
        return null;
    }

    private void displayMessageNotificationFromNotifiable(
            Notifiable notif, String remoteSipUri, String localSipUri) {
        Intent notifIntent = new Intent(mContext, ChatActivity.class);
        notifIntent.putExtra("RemoteSipUri", remoteSipUri);
        notifIntent.putExtra("LocalSipUri", localSipUri);
        addFlagsToIntent(notifIntent);

        PendingIntent pendingIntent =
                PendingIntent.getActivity(
                        mContext,
                        notif.getNotificationId(),
                        notifIntent,
                        PendingIntent.FLAG_UPDATE_CURRENT);

        NotifiableMessage lastNotifiable = notif.getMessages().get(notif.getMessages().size() - 1);
        String from = lastNotifiable.getSender();
        String message = lastNotifiable.getMessage();
        Bitmap bm = lastNotifiable.getSenderBitmap();
        if (notif.isGroup()) {
            message =
                    mContext.getString(R.string.group_chat_notif)
                            .replace("%1", from)
                            .replace("%2", message);
            from = notif.getGroupTitle();
        }

        Notification notification =
                Compatibility.createMessageNotification(
                        mContext, notif, from, message, bm, pendingIntent);
        sendNotification(notif.getNotificationId(), notification);
    }

    private void displayReplyMessageNotification(ChatMessage msg, Notifiable notif) {
        if (msg == null || notif == null) return;
        Log.i(
                "[Notifications Manager] Updating message notification with reply for notif "
                        + notif.getNotificationId());

        NotifiableMessage notifMessage =
                new NotifiableMessage(
                        msg.getTextContent(),
                        notif.getMyself(),
                        System.currentTimeMillis(),
                        null,
                        null);
        notif.addMessage(notifMessage);

        ChatRoom cr = msg.getChatRoom();

        displayMessageNotificationFromNotifiable(
                notif,
                cr.getPeerAddress().asStringUriOnly(),
                cr.getLocalAddress().asStringUriOnly());
    }

    public void displayGroupChatMessageNotification(
            String subject,
            String conferenceAddress,
            String fromName,
            Uri fromPictureUri,
            String message,
            Address localIdentity,
            long timestamp,
            Uri filePath,
            String fileMime) {

        Bitmap bm = ImageUtils.getRoundBitmapFromUri(mContext, fromPictureUri);
        Notifiable notif = mChatNotifMap.get(conferenceAddress);
        NotifiableMessage notifMessage =
                new NotifiableMessage(message, fromName, timestamp, filePath, fileMime);
        if (notif == null) {
            notif = new Notifiable(mLastNotificationId);
            mLastNotificationId += 1;
            mChatNotifMap.put(conferenceAddress, notif);
        }
        Log.i("[Notifications Manager] Creating group chat message notifiable " + notif);

        notifMessage.setSenderBitmap(bm);
        notif.addMessage(notifMessage);
        notif.setIsGroup(true);
        notif.setGroupTitle(subject);
        notif.setMyself(LinphoneUtils.getAddressDisplayName(localIdentity));
        notif.setLocalIdentity(localIdentity.asString());

        displayMessageNotificationFromNotifiable(
                notif, conferenceAddress, localIdentity.asStringUriOnly());
    }

    public void displayMessageNotification(
            String fromSipUri,
            String fromName,
            Uri fromPictureUri,
            String message,
            Address localIdentity,
            long timestamp,
            Uri filePath,
            String fileMime) {
        if (fromName == null) {
            fromName = fromSipUri;
        }

        Bitmap bm = ImageUtils.getRoundBitmapFromUri(mContext, fromPictureUri);
        Notifiable notif = mChatNotifMap.get(fromSipUri);
        NotifiableMessage notifMessage =
                new NotifiableMessage(message, fromName, timestamp, filePath, fileMime);
        if (notif == null) {
            notif = new Notifiable(mLastNotificationId);
            mLastNotificationId += 1;
            mChatNotifMap.put(fromSipUri, notif);
        }
        Log.i("[Notifications Manager] Creating chat message notifiable " + notif);

        notifMessage.setSenderBitmap(bm);
        notif.addMessage(notifMessage);
        notif.setIsGroup(false);
        notif.setMyself(LinphoneUtils.getAddressDisplayName(localIdentity));
        notif.setLocalIdentity(localIdentity.asString());

        displayMessageNotificationFromNotifiable(
                notif, fromSipUri, localIdentity.asStringUriOnly());
    }

    public void displayMissedCallNotification(Call call) {
        Intent missedCallNotifIntent = new Intent(mContext, HistoryActivity.class);
        addFlagsToIntent(missedCallNotifIntent);

        PendingIntent pendingIntent =
                PendingIntent.getActivity(
                        mContext,
                        MISSED_CALLS_NOTIF_ID,
                        missedCallNotifIntent,
                        PendingIntent.FLAG_UPDATE_CURRENT);

        int missedCallCount = LinphoneManager.getCore().getMissedCallsCount();
        String body;
        if (missedCallCount > 1) {
            body =
                    mContext.getString(R.string.missed_calls_notif_body)
                            .replace("%i", String.valueOf(missedCallCount));
            Log.i("[Notifications Manager] Creating missed calls notification");
        } else {
            Address address = call.getRemoteAddress();
            LinphoneContact c = ContactsManager.getInstance().findContactFromAddress(address);
            if (c != null) {
                body = c.getFullName();
            } else {
                body = address.getDisplayName();
                if (body == null) {
                    body = address.asStringUriOnly();
                }
            }
            Log.i("[Notifications Manager] Creating missed call notification");
        }

        Notification notif =
                Compatibility.createMissedCallNotification(
                        mContext,
                        mContext.getString(R.string.missed_calls_notif_title),
                        body,
                        pendingIntent,
                        missedCallCount);
        sendNotification(MISSED_CALLS_NOTIF_ID, notif);
    }

    public void displayCallNotification(Call call) {
        if (call == null) return;

        Class callNotifIntentClass = CallActivity.class;
        if (call.getState() == Call.State.IncomingReceived
                || call.getState() == Call.State.IncomingEarlyMedia) {
            callNotifIntentClass = CallIncomingActivity.class;
        } else if (call.getState() == Call.State.OutgoingInit
                || call.getState() == Call.State.OutgoingProgress
                || call.getState() == Call.State.OutgoingRinging
                || call.getState() == Call.State.OutgoingEarlyMedia) {
            callNotifIntentClass = CallOutgoingActivity.class;
        }
        Intent callNotifIntent = new Intent(mContext, callNotifIntentClass);
        callNotifIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        PendingIntent pendingIntent =
                PendingIntent.getActivity(
                        mContext, 0, callNotifIntent, PendingIntent.FLAG_UPDATE_CURRENT);

        Address address = call.getRemoteAddress();
        String addressAsString = address.asStringUriOnly();
        Notifiable notif = mCallNotifMap.get(addressAsString);
        if (notif == null) {
            notif = new Notifiable(mLastNotificationId);
            mLastNotificationId += 1;
            mCallNotifMap.put(addressAsString, notif);
        }

        int notificationTextId;
        int iconId;
        switch (call.getState()) {
            case Released:
            case End:
                if (mCurrentForegroundServiceNotification == notif.getNotificationId()) {
                    Log.i(
                            "[Notifications Manager] Call ended, stopping notification used to keep service alive");
                    // Call is released, remove service notification to allow for an other call to
                    // be service notification
                    stopForeground();
                }
                mNM.cancel(notif.getNotificationId());
                mCallNotifMap.remove(addressAsString);
                return;
            case Paused:
            case PausedByRemote:
            case Pausing:
                iconId = R.drawable.topbar_call_notification;
                notificationTextId = R.string.incall_notif_paused;
                break;
            case IncomingEarlyMedia:
            case IncomingReceived:
                iconId = R.drawable.topbar_call_notification;
                notificationTextId = R.string.incall_notif_incoming;
                break;
            case OutgoingEarlyMedia:
            case OutgoingInit:
            case OutgoingProgress:
            case OutgoingRinging:
                iconId = R.drawable.topbar_call_notification;
                notificationTextId = R.string.incall_notif_outgoing;
                break;
            default:
                if (call.getCurrentParams().videoEnabled()) {
                    iconId = R.drawable.topbar_videocall_notification;
                    notificationTextId = R.string.incall_notif_video;
                } else {
                    iconId = R.drawable.topbar_call_notification;
                    notificationTextId = R.string.incall_notif_active;
                }
                break;
        }

        if (notif.getIconResourceId() == iconId
                && notif.getTextResourceId() == notificationTextId) {
            // Notification hasn't changed, do not "update" it to avoid blinking
            return;
        } else if (notif.getTextResourceId() == R.string.incall_notif_incoming) {
            // If previous notif was incoming call, as we will switch channels, dismiss it first
            dismissNotification(notif.getNotificationId());
        }

        notif.setIconResourceId(iconId);
        notif.setTextResourceId(notificationTextId);
        Log.i(
                "[Notifications Manager] Call notification notifiable is "
                        + notif
                        + ", pending intent "
                        + callNotifIntentClass);

        LinphoneContact contact = ContactsManager.getInstance().findContactFromAddress(address);
        Uri pictureUri = contact != null ? contact.getThumbnailUri() : null;
        Bitmap bm = ImageUtils.getRoundBitmapFromUri(mContext, pictureUri);
        String name =
                contact != null
                        ? contact.getFullName()
                        : LinphoneUtils.getAddressDisplayName(address);
        boolean isIncoming = callNotifIntentClass == CallIncomingActivity.class;

        Notification notification;
        if (isIncoming) {
            notification =
                    Compatibility.createIncomingCallNotification(
                            mContext,
                            notif.getNotificationId(),
                            bm,
                            name,
                            addressAsString,
                            pendingIntent);
        } else {
            notification =
                    Compatibility.createInCallNotification(
                            mContext,
                            notif.getNotificationId(),
                            mContext.getString(notificationTextId),
                            iconId,
                            bm,
                            name,
                            pendingIntent);
        }

        // Don't use incoming call notification as foreground service notif !
        if (!isServiceNotificationDisplayed() && !isIncoming) {
            if (call.getCore().getCallsNb() == 0) {
                Log.i(
                        "[Notifications Manager] Foreground service mode is disabled, stopping call notification used to keep it alive");
                stopForeground();
            } else {
                if (mCurrentForegroundServiceNotification == 0) {
                    if (DeviceUtils.isAppUserRestricted(mContext)) {
                        Log.w(
                                "[Notifications Manager] App has been restricted, can't use call notification to keep service alive !");
                        sendNotification(notif.getNotificationId(), notification);
                    } else {
                        Log.i(
                                "[Notifications Manager] Foreground service mode is disabled, using call notification to keep it alive");
                        startForeground(notification, notif.getNotificationId());
                    }
                } else {
                    sendNotification(notif.getNotificationId(), notification);
                }
            }
        } else {
            sendNotification(notif.getNotificationId(), notification);
        }
    }

    public String getSipUriForCallNotificationId(int notificationId) {
        for (String addr : mCallNotifMap.keySet()) {
            if (mCallNotifMap.get(addr).getNotificationId() == notificationId) {
                return addr;
            }
        }
        return null;
    }

    private void createNotification(
            ChatRoom cr,
            LinphoneContact contact,
            Address from,
            String textMessage,
            long time,
            Uri file,
            String mime) {
        if (cr.hasCapability(ChatRoomCapabilities.OneToOne.toInt())) {
            if (contact != null) {
                displayMessageNotification(
                        cr.getPeerAddress().asStringUriOnly(),
                        contact.getFullName(),
                        contact.getThumbnailUri(),
                        textMessage,
                        cr.getLocalAddress(),
                        time,
                        file,
                        mime);
            } else {
                displayMessageNotification(
                        cr.getPeerAddress().asStringUriOnly(),
                        from.getUsername(),
                        null,
                        textMessage,
                        cr.getLocalAddress(),
                        time,
                        file,
                        mime);
            }
        } else {
            String subject = cr.getSubject();
            if (contact != null) {
                displayGroupChatMessageNotification(
                        subject,
                        cr.getPeerAddress().asStringUriOnly(),
                        contact.getFullName(),
                        contact.getThumbnailUri(),
                        textMessage,
                        cr.getLocalAddress(),
                        time,
                        file,
                        mime);
            } else {
                displayGroupChatMessageNotification(
                        subject,
                        cr.getPeerAddress().asStringUriOnly(),
                        from.getUsername(),
                        null,
                        textMessage,
                        cr.getLocalAddress(),
                        time,
                        file,
                        mime);
            }
        }
    }
}