/*
 * Copyright (c) 2010-2020 Belledonne Communications SARL.
 *
 * This file is part of linphone-iphone
 *
 * 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/>.
 */

#import "LinphoneManager.h"
#import "ChatConversationTableView.h"
#import "ChatConversationImdnView.h"
#import "UIChatBubbleTextCell.h"
#import "UIChatBubblePhotoCell.h"
#import "UIChatNotifiedEventCell.h"
#import "PhoneMainView.h"

@implementation ChatConversationTableView

#pragma mark - Lifecycle Functions

- (void)dealloc {
	[self clearEventList];
}


#pragma mark - ViewController Functions

- (void)viewWillAppear:(BOOL)animated {
	[super viewWillAppear:animated];
	self.tableView.accessibilityIdentifier = @"ChatRoom list";
    _imagesInChatroom = [NSMutableDictionary dictionary];
	_currentIndex = 0;
	[self startEphemeralDisplayTimer];
	[NSNotificationCenter.defaultCenter addObserver:self
										   selector:@selector(ephemeralDeleted:)
											   name:kLinphoneEphemeralMessageDeletedInRoom
											 object:nil];
}

-(void) viewWillDisappear:(BOOL)animated {
	[self stopEphemeralDisplayTimer];
	[NSNotificationCenter.defaultCenter removeObserver:self];
	[super viewWillDisappear:animated];
}

#pragma mark -

- (void)clearEventList {
    for (NSValue *value in totalEventList) {
        LinphoneEventLog *event = value.pointerValue;
        linphone_event_log_unref(event);
    }
    [eventList removeAllObjects];
    [totalEventList removeAllObjects];
}

-(bool) eventTypeIsOfInterestForOneToOneRoom:(LinphoneEventLogType)type {
	return
	type == LinphoneEventLogTypeConferenceChatMessage ||
	type == LinphoneEventLogTypeConferenceEphemeralMessageEnabled ||
	type == LinphoneEventLogTypeConferenceEphemeralMessageDisabled ||
	type == LinphoneEventLogTypeConferenceEphemeralMessageLifetimeChanged;
}

- (void)updateData {
	[self clearEventList];
	if (!_chatRoom)
		return;
	
	LinphoneChatRoomCapabilitiesMask capabilities = linphone_chat_room_get_capabilities(_chatRoom);
	bool oneToOne = capabilities & LinphoneChatRoomCapabilitiesOneToOne;
	bctbx_list_t *chatRoomEvents = linphone_chat_room_get_history_events(_chatRoom, 0);
	
	
	bctbx_list_t *head = chatRoomEvents;
	size_t listSize = bctbx_list_size(chatRoomEvents);
	totalEventList = [[NSMutableArray alloc] initWithCapacity:listSize];
	eventList = [[NSMutableArray alloc] initWithCapacity:MIN(listSize, BASIC_EVENT_LIST)];
	BOOL autoDownload = (linphone_core_get_max_size_for_auto_download_incoming_files(LC) > -1);
	while (chatRoomEvents) {
		LinphoneEventLog *event = (LinphoneEventLog *)chatRoomEvents->data;
		if (oneToOne && ![self eventTypeIsOfInterestForOneToOneRoom:linphone_event_log_get_type(event)]) {
			chatRoomEvents = chatRoomEvents->next;
		} else {
			LinphoneChatMessage *chat = linphone_event_log_get_chat_message(event);
			// if auto_download is available and file transfer in progress, not add event now
			if (!(autoDownload && chat && linphone_chat_message_is_file_transfer_in_progress(chat))) {
				[totalEventList addObject:[NSValue valueWithPointer:linphone_event_log_ref(event)]];
				if (listSize <= BASIC_EVENT_LIST) {
					[eventList addObject:[NSValue valueWithPointer:linphone_event_log_ref(event)]];
				}
			}
			
			chatRoomEvents = chatRoomEvents->next;
			listSize -= 1;
		}
	}
	bctbx_list_free_with_data(head, (bctbx_list_free_func)linphone_event_log_unref);
}

- (void)refreshData {
    if (totalEventList.count <= eventList.count) {
        _currentIndex = 0;
        return;
    }
    
    NSUInteger num = MIN(totalEventList.count-eventList.count, BASIC_EVENT_LIST);
    _currentIndex = num - 1;
    while (num) {
        NSInteger index = totalEventList.count - eventList.count - 1;
        [eventList insertObject:[totalEventList objectAtIndex:index] atIndex:0];
        index -= 1;
        num -= 1;
    }
}

- (void)reloadData {
	[self updateData];
	[self.tableView reloadData];
	[self scrollToLastUnread:false];
}

- (void)addEventEntry:(LinphoneEventLog *)event {
	[eventList addObject:[NSValue valueWithPointer:linphone_event_log_ref(event)]];
    [totalEventList addObject:[NSValue valueWithPointer:linphone_event_log_ref(event)]];
	int pos = (int)eventList.count - 1;
	NSIndexPath *indexPath = [NSIndexPath indexPathForRow:pos inSection:0];
	[self.tableView beginUpdates];
	[self.tableView insertRowsAtIndexPaths:@[ indexPath ] withRowAnimation:UITableViewRowAnimationFade];
    [self.tableView reloadData];
	[self.tableView endUpdates];
}

- (void)updateEventEntry:(LinphoneEventLog *)event {
	NSInteger index = [eventList indexOfObject:[NSValue valueWithPointer:event]];
	if (index < 0) {
		LOGW(@"event entry doesn't exist");
		return;
	}
	[self.tableView reloadRowsAtIndexPaths:[NSArray arrayWithObject:[NSIndexPath indexPathForRow:index inSection:0]]
						  withRowAnimation:FALSE]; // just reload
    return;
}

- (void)scrollToBottom:(BOOL)animated {
	//[self.tableView reloadData];
	size_t count = eventList.count;
	if (!count)
		return;

	//[self.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:(count - 1) inSection:0]];
	[self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:(count - 1) inSection:0]
						  atScrollPosition:UITableViewScrollPositionBottom
								  animated:YES];
}

- (void)scrollToLastUnread:(BOOL)animated {
	if (eventList.count == 0 || _chatRoom == nil)
		return;

	int index = -1;
	size_t count = eventList.count;
	// Find first unread & set all entry read
	for (int i = (int)count - 1; i > 0; --i) {
		LinphoneEventLog *event = [[eventList objectAtIndex:i] pointerValue];
		if (!(linphone_event_log_get_type(event) == LinphoneEventLogTypeConferenceChatMessage))
			break;

		LinphoneChatMessage *chat = linphone_event_log_get_chat_message(event);
		int read = linphone_chat_message_is_read(chat);
		LinphoneChatMessageState state = linphone_chat_message_get_state(chat);
		if (read == 0 &&
			!(state == LinphoneChatMessageStateFileTransferError || state == LinphoneChatMessageStateNotDelivered)) {
			if (index == -1) {
				index = i;
				break;
			}
		}
	}
	if (index == -1 && count > 0)
		index = (int)count - 1;

	if ([UIApplication sharedApplication].applicationState == UIApplicationStateActive)
		[ChatConversationView markAsRead:_chatRoom];

	// Scroll to unread
	if (index < 0)
		return;

	[self.tableView.layer removeAllAnimations];
	[self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:index inSection:0]
						  atScrollPosition:UITableViewScrollPositionTop
								  animated:animated];
}

#pragma mark - Property Functions

- (void)setChatRoom:(LinphoneChatRoom *)room {
	_chatRoom = room;
	[self reloadData];
	[self updateEphemeralTimes];
}

static const int MAX_AGGLOMERATED_TIME=300;
static const int BASIC_EVENT_LIST=15;

- (BOOL)isFirstIndexInTableView:(NSIndexPath *)indexPath chat:(LinphoneChatMessage *)chat {
    LinphoneEventLog *previousEvent = nil;
    NSInteger indexOfPreviousEvent = indexPath.row - 1;
    if (indexOfPreviousEvent > -1) {
		previousEvent = [[eventList objectAtIndex:indexOfPreviousEvent] pointerValue];
        if (linphone_event_log_get_type(previousEvent) != LinphoneEventLogTypeConferenceChatMessage) {
			return TRUE;
        }
    }
    if (!previousEvent)
        return TRUE;

    LinphoneChatMessage *previousChat = linphone_event_log_get_chat_message(previousEvent);
    if (!linphone_address_equal(linphone_chat_message_get_from_address(previousChat), linphone_chat_message_get_from_address(chat))) {
        return TRUE;
    }
    // the maximum interval between 2 agglomerated chats at 5mn
    if ((linphone_chat_message_get_time(chat)-linphone_chat_message_get_time(previousChat)) > MAX_AGGLOMERATED_TIME) {
        return TRUE;
    }
        
    return FALSE;
}

- (BOOL)isLastIndexInTableView:(NSIndexPath *)indexPath chat:(LinphoneChatMessage *)chat {
    LinphoneEventLog *nextEvent = nil;
    NSInteger indexOfNextEvent = indexPath.row + 1;
    while (!nextEvent && indexOfNextEvent < [eventList count]) {
        LinphoneEventLog *tmp = [[eventList objectAtIndex:indexOfNextEvent] pointerValue];
        if (linphone_event_log_get_type(tmp) == LinphoneEventLogTypeConferenceChatMessage) {
            nextEvent = tmp;
        }
        ++indexOfNextEvent;
    }
    
    if (!nextEvent)
        return TRUE;

    LinphoneChatMessage *nextChat = linphone_event_log_get_chat_message(nextEvent);
    if (!linphone_address_equal(linphone_chat_message_get_from_address(nextChat), linphone_chat_message_get_from_address(chat))) {
        return TRUE;
    }
    
    return FALSE;
}

#pragma mark - UITableViewDataSource Functions

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
	return 1;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
	return eventList.count;
}

- (void)tableView:(UITableView *)tableView didEndDisplayingCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath*)indexPath {
	if (!_chatRoom && [[cell reuseIdentifier] isEqualToString:@"UIChatBubblePhotoCell"]) {
		[(UIChatBubbleTextCell *)cell clearEncryptedFiles];
	}
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
	NSString *kCellId = nil;
	LinphoneEventLog *event = [[eventList objectAtIndex:indexPath.row] pointerValue];
	if (linphone_event_log_get_type(event) == LinphoneEventLogTypeConferenceChatMessage) {
		LinphoneChatMessage *chat = linphone_event_log_get_chat_message(event);
        if (linphone_chat_message_get_file_transfer_information(chat) || linphone_chat_message_get_external_body_url(chat))
            kCellId = NSStringFromClass(UIChatBubblePhotoCell.class);
		else
			kCellId = NSStringFromClass(UIChatBubbleTextCell.class);

		// To use less memory and to avoid overlapping. To be improved.
		UIChatBubbleTextCell *cell = [tableView dequeueReusableCellWithIdentifier:kCellId];
		cell = [[NSClassFromString(kCellId) alloc] initWithIdentifier:kCellId];

		[cell setEvent:event];
        if (chat) {
            cell.isFirst = [self isFirstIndexInTableView:indexPath chat:chat];
            cell.isLast = [self isLastIndexInTableView:indexPath chat:chat];
            [cell update];
        }

		[cell setChatRoomDelegate:_chatRoomDelegate];
		[super accessoryForCell:cell atPath:indexPath];
		cell.selectionStyle = UITableViewCellSelectionStyleNone;
		return cell;
	} else {
		kCellId = NSStringFromClass(UIChatNotifiedEventCell.class);
		UIChatNotifiedEventCell *cell = [tableView dequeueReusableCellWithIdentifier:kCellId];
		if (!cell)
			cell = [[NSClassFromString(kCellId) alloc] initWithIdentifier:kCellId];

		[cell setEvent:event];
		[super accessoryForCell:cell atPath:indexPath];
		cell.selectionStyle = UITableViewCellSelectionStyleNone;
		return cell;
	}
}

#pragma mark - UITableViewDelegate Functions

- (void)scrollViewWillBeginDragging:(UIScrollView *)scrollView {
	[_chatRoomDelegate tableViewIsScrolling];
}

static const CGFloat MESSAGE_SPACING_PERCENTAGE = 1.f;

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
	LinphoneEventLog *event = [[eventList objectAtIndex:indexPath.row] pointerValue];
	if (linphone_event_log_get_type(event) == LinphoneEventLogTypeConferenceChatMessage) {
        LinphoneChatMessage *chat = linphone_event_log_get_chat_message(event);
        
        //If the message is followed by another one that is not from the same address, we add a little space under it
        CGFloat height = 0;
        if ([self isLastIndexInTableView:indexPath chat:chat])
            height += tableView.frame.size.height * MESSAGE_SPACING_PERCENTAGE / 100;
        if (![self isFirstIndexInTableView:indexPath chat:chat])
            height -= 20;

		return [UIChatBubbleTextCell ViewHeightForMessage:chat withWidth:self.view.frame.size.width].height + height;
	}
    return [UIChatNotifiedEventCell height];
}

- (void) tableView:(UITableView *)tableView deleteRowAtIndex:(NSIndexPath *)indexPath {
	[tableView beginUpdates];
	LinphoneEventLog *event = [[eventList objectAtIndex:indexPath.row] pointerValue];
	linphone_event_log_delete_from_database(event);
	NSInteger index = indexPath.row + _currentIndex + (totalEventList.count - eventList.count);
	if (index < totalEventList.count)
		[totalEventList removeObjectAtIndex:index];
	[eventList removeObjectAtIndex:indexPath.row];

	[tableView deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath]
					 withRowAnimation:UITableViewRowAnimationBottom];
	[tableView endUpdates];
    [self loadData];
}

- (NSArray<UITableViewRowAction *> *)tableView:(UITableView *)tableView
				  editActionsForRowAtIndexPath:(NSIndexPath *)indexPath {
	LinphoneEventLog *event = [[eventList objectAtIndex:indexPath.row] pointerValue];
	UITableViewRowAction *deleteAction = [UITableViewRowAction rowActionWithStyle:UITableViewRowActionStyleDestructive
																			title:NSLocalizedString(@"Delete", nil)
																		  handler:^(UITableViewRowAction *action, NSIndexPath *indexPath){
																			  [self tableView:tableView deleteRowAtIndex:indexPath];
																		  }];

	UITableViewRowAction *imdnAction = [UITableViewRowAction rowActionWithStyle:UITableViewRowActionStyleNormal
																			title:NSLocalizedString(@"Info", nil)
																		  handler:^(UITableViewRowAction *action, NSIndexPath *indexPath){
																			  LinphoneChatMessage *msg = linphone_event_log_get_chat_message(event);
																			  ChatConversationImdnView *view = VIEW(ChatConversationImdnView);
																			  view.msg = msg;
																			  [PhoneMainView.instance changeCurrentView:view.compositeViewDescription];
																		  }];

	if (linphone_event_log_get_type(event) == LinphoneEventLogTypeConferenceChatMessage &&
		!(linphone_chat_room_get_capabilities(_chatRoom) & LinphoneChatRoomCapabilitiesOneToOne))
		return @[deleteAction, imdnAction];
	else
		return @[deleteAction];
}

- (void)tableView:(UITableView *)tableView
	commitEditingStyle:(UITableViewCellEditingStyle)editingStyle
	 forRowAtIndexPath:(NSIndexPath *)indexPath {
	if (editingStyle == UITableViewCellEditingStyleDelete) {
		[self tableView:tableView deleteRowAtIndex:indexPath];
	}
}

- (void)removeSelectionUsing:(void (^)(NSIndexPath *))remover {
	[super removeSelectionUsing:^(NSIndexPath *indexPath) {
		LinphoneEventLog *event = [[eventList objectAtIndex:indexPath.row] pointerValue];
		if (linphone_event_log_get_chat_message(event)) {
			linphone_chat_room_delete_message(_chatRoom, linphone_event_log_get_chat_message(event));
		}
        NSInteger index = indexPath.row + _currentIndex + (totalEventList.count - eventList.count);
        if (index < totalEventList.count)
            [totalEventList removeObjectAtIndex:index];
		[eventList removeObjectAtIndex:indexPath.row];
	}];
}

#pragma mark ephemeral messages

-(void) startEphemeralDisplayTimer {
	_ephemeralDisplayTimer = [NSTimer scheduledTimerWithTimeInterval:1
															  target:self
															selector:@selector(updateEphemeralTimes)
															userInfo:nil
															 repeats:YES];
}

-(void) updateEphemeralTimes {
	NSDateComponentsFormatter *f= [[NSDateComponentsFormatter alloc] init];
	f.unitsStyle = NSDateComponentsFormatterUnitsStylePositional;
	f.zeroFormattingBehavior = NSDateComponentsFormatterZeroFormattingBehaviorPad;
		
	for (NSValue *v in eventList) {
		LinphoneEventLog *event = [v pointerValue];
		if (linphone_event_log_get_type(event) == LinphoneEventLogTypeConferenceChatMessage) {
			LinphoneChatMessage *msg = linphone_event_log_get_chat_message(event);
			if (linphone_chat_message_is_ephemeral(msg)) {
				UIChatBubbleTextCell *cell = (UIChatBubbleTextCell  *)[self.tableView cellForRowAtIndexPath:[NSIndexPath indexPathForRow:[eventList indexOfObject:v] inSection:0]];
				long duration = linphone_chat_message_get_ephemeral_expire_time(msg) == 0 ?
					linphone_chat_room_get_ephemeral_lifetime(linphone_chat_message_get_chat_room(msg)) :
					linphone_chat_message_get_ephemeral_expire_time(msg)-[NSDate date].timeIntervalSince1970;
				f.allowedUnits = (duration > 86400 ? kCFCalendarUnitDay : 0)|(duration > 3600 ? kCFCalendarUnitHour : 0)|kCFCalendarUnitMinute|kCFCalendarUnitSecond;
				cell.ephemeralTime.text =  [f stringFromTimeInterval:duration];
				cell.ephemeralTime.hidden = NO;
				cell.ephemeralIcon.hidden = NO;
			}
		}
	}
}

-(void) stopEphemeralDisplayTimer {
	[_ephemeralDisplayTimer invalidate];
}

- (void)ephemeralDeleted:(NSNotification *)notif {
	LinphoneChatRoom *r =[[notif.userInfo objectForKey:@"room"] pointerValue];
	if (r ==_chatRoom)
		[self reloadData];
}

@end