/*
 * Copyright 2017 Samsung Electronics Co., Ltd
 *
 * Licensed under the Flora License, Version 1.1 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://floralicense.org/license/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "Model/DataProvider.h"

using namespace Model;

DataProvider::DataProvider()
	: m_IsBusy(false), m_IsInitialized(false),
	  m_IsUpdateEnabled(true), m_IsUpdatePending(false),
	  m_IsDestroyPending(false)
{
}

DataProvider::~DataProvider()
{
	for (auto &&dataItem : m_DataList) {
		delete dataItem;
	}
}

const DataProvider::DataList &DataProvider::getDataList()
{
	return m_DataList;
}

void DataProvider::initialize(InitializeCallback callback)
{
	if (m_IsInitialized || m_IsBusy) {
		return;
	}

	m_IsBusy = true;
	m_OnInitialized = std::move(callback);

	startInit();
}

void DataProvider::update()
{
	if (!m_IsInitialized) {
		return;
	}

	if (!m_IsUpdateEnabled || m_IsBusy) {
		m_IsUpdatePending = true;
		return;
	}

	m_IsBusy = true;
	m_IsUpdatePending = false;
	m_OnUpdateStarted();

	startUpdate();
}

void DataProvider::destroy()
{
	if (m_IsBusy) {
		m_IsDestroyPending = true;
	} else {
		delete this;
	}
}

void DataProvider::setUpdateEnabled(bool isEnabled)
{
	m_IsUpdateEnabled = isEnabled;
	if (m_IsUpdateEnabled && m_IsUpdatePending) {
		update();
	}
}

DataProvider::InsertCallback &DataProvider::onInserted()
{
	return m_OnInserted;
}

DataProvider::UpdateCallback &DataProvider::onUpdateStarted()
{
	return m_OnUpdateStarted;
}

DataProvider::UpdateCallback &DataProvider::onUpdateFinished()
{
	return m_OnUpdateFinished;
}

void DataProvider::insertDataItem(DataItem *dataItem)
{
	dataItem->m_ChangeType = ChangeInsert;
	m_DataList.push_back(dataItem);
}

void DataProvider::deleteDataItem(DataItem &dataItem)
{
	dataItem.m_ChangeType = ChangeDelete;
}

void DataProvider::finishInit(DataList dataList)
{
	if (m_IsDestroyPending) {
		delete this;
		return;
	}

	m_DataList = std::move(dataList);
	m_IsInitialized = true;

	if (m_OnInitialized) {
		m_OnInitialized();
		m_OnInitialized = nullptr;
	}

	m_IsBusy = false;
}

void DataProvider::finishUpdate()
{
	if (m_IsDestroyPending) {
		delete this;
		return;
	}

	for (auto it = m_DataList.begin(); it != m_DataList.end(); ) {
		auto changeType = (*it)->m_ChangeType;
		(*it)->finishUpdate();

		if (changeType == ChangeInsert) {
			if (m_OnInserted) {
				m_OnInserted(**it);
			}
		} else if (changeType == ChangeDelete) {
			delete *it;
			it = m_DataList.erase(it);
			continue;
		}

		++it;
	}
	m_OnUpdateFinished();

	m_IsBusy = false;
	if (m_IsUpdatePending) {
		update();
	}
}