diff --git a/autotests/unittests/editablecourseresource/test_editablecourseresource.cpp b/autotests/unittests/editablecourseresource/test_editablecourseresource.cpp
index 883e674..02e7e4a 100644
--- a/autotests/unittests/editablecourseresource/test_editablecourseresource.cpp
+++ b/autotests/unittests/editablecourseresource/test_editablecourseresource.cpp
@@ -1,364 +1,364 @@
 /*
  *  Copyright 2013-2019  Andreas Cord-Landwehr <cordlandwehr@kde.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 2 of
  *  the License or (at your option) version 3 or any later version
  *  accepted by the membership of KDE e.V. (or its successor approved
  *  by the membership of KDE e.V.), which shall act as a proxy
  *  defined in Section 14 of version 3 of the license.
  *
  *  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/>.
  */
 
 #include "test_editablecourseresource.h"
 #include "resourcerepositorystub.h"
 #include "core/language.h"
 #include "core/unit.h"
 #include "core/phrase.h"
 #include "core/resources/courseparser.h"
 #include "core/resources/editablecourseresource.h"
 #include "../mocks/languagestub.h"
 #include "../mocks/coursestub.h"
 
 #include <memory>
 #include <QTest>
 #include <QDebug>
 #include <QTemporaryFile>
 #include <QSignalSpy>
 #include <QIODevice>
 #include <QFile>
 #include <QXmlSchema>
 #include <QXmlSchemaValidator>
 #include <QDomDocument>
 
 TestEditableCourseResource::TestEditableCourseResource()
 {
 }
 
 void TestEditableCourseResource::init()
 {
 }
 
 void TestEditableCourseResource::cleanup()
 {
 }
 
 void TestEditableCourseResource::loadCourseResource()
 {
     std::shared_ptr<ILanguage> language(new LanguageStub("de"));
     ResourceRepositoryStub repository({language});
 
     auto course = EditableCourseResource::create(QUrl::fromLocalFile(":/courses/de.xml"), &repository);
     QCOMPARE(course->file().toLocalFile(), ":/courses/de.xml");
     QCOMPARE(course->id(), "de");
     QCOMPARE(course->foreignId(), "artikulate-basic");
     QCOMPARE(course->title(), "Artikulate Deutsch");
     QCOMPARE(course->description(), "Ein Kurs in (hoch-)deutscher Aussprache.");
     QVERIFY(course->language() != nullptr);
     QCOMPARE(course->language()->id(), "de");
     QCOMPARE(course->units().count(), 1);
     QCOMPARE(course->units().first()->course(), course);
 
     const auto unit = course->units().first();
     QVERIFY(unit != nullptr);
     QCOMPARE(unit->id(), "1");
     QCOMPARE(unit->title(), QStringLiteral("Auf der Straße"));
     QCOMPARE(unit->foreignId(), "{dd60f04a-eb37-44b7-9787-67aaf7d3578d}");
     QCOMPARE(unit->course(), course);
 
     QCOMPARE(unit->phrases().count(), 3);
     // note: this test takes the silent assumption that phrases are added to the list in same
     //   order as they are defined in the file. This assumption should be made explicit or dropped
     const auto firstPhrase = unit->phrases().first();
     QVERIFY(firstPhrase != nullptr);
     QCOMPARE(firstPhrase->id(), "1");
     QCOMPARE(firstPhrase->foreignId(), "{3a4c1926-60d7-44c6-80d1-03165a641c75}");
     QCOMPARE(firstPhrase->text(), "Guten Tag.");
     QCOMPARE(firstPhrase->soundFileUrl(), ":/courses/de_01.ogg");
     QCOMPARE(firstPhrase->type(), Phrase::Type::Sentence);
     QVERIFY(firstPhrase->phonemes().isEmpty());
 }
 
 void TestEditableCourseResource::unitAddAndRemoveHandling()
 {
     // boilerplate
     std::shared_ptr<ILanguage> language(new LanguageStub("de"));
     ResourceRepositoryStub repository({language});
     auto course = EditableCourseResource::create(QUrl::fromLocalFile(":/courses/de.xml"), &repository);
 
     // begin of test
     auto unit = Unit::create();
     unit->setId("testunit");
     const int initialUnitNumber = course->units().count();
     QCOMPARE(initialUnitNumber, 1);
     QSignalSpy spyAboutToBeAdded(course.get(), SIGNAL(unitAboutToBeAdded(std::shared_ptr<Unit>, int)));
     QSignalSpy spyAdded(course.get(), SIGNAL(unitAdded()));
     QCOMPARE(spyAboutToBeAdded.count(), 0);
     QCOMPARE(spyAdded.count(), 0);
     auto sharedUnit = course->addUnit(std::move(unit));
     QCOMPARE(course->units().count(), initialUnitNumber + 1);
     QCOMPARE(spyAboutToBeAdded.count(), 1);
     QCOMPARE(spyAdded.count(), 1);
     QCOMPARE(sharedUnit->course(), course);
 }
 
 void TestEditableCourseResource::coursePropertyChanges()
 {
     // boilerplate
     std::shared_ptr<ILanguage> language(new LanguageStub("de"));
     ResourceRepositoryStub repository({language});
     auto course = CourseResource::create(QUrl::fromLocalFile(":/courses/de.xml"), &repository);
 
     // id
     {
         const QString value = "newId";
         QSignalSpy spy(course.get(), SIGNAL(idChanged()));
         QCOMPARE(spy.count(), 0);
         course->setId(value);
         QCOMPARE(course->id(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // foreign id
     {
         const QString value = "newForeignId";
         QSignalSpy spy(course.get(), SIGNAL(foreignIdChanged()));
         QCOMPARE(spy.count(), 0);
         course->setForeignId(value);
         QCOMPARE(course->foreignId(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // title
     {
         const QString value = "newTitle";
         QSignalSpy spy(course.get(), SIGNAL(titleChanged()));
         QCOMPARE(spy.count(), 0);
         course->setTitle(value);
         QCOMPARE(course->title(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // title
     {
         const QString value = "newI18nTitle";
         QSignalSpy spy(course.get(), SIGNAL(i18nTitleChanged()));
         QCOMPARE(spy.count(), 0);
         course->setI18nTitle(value);
         QCOMPARE(course->i18nTitle(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // description
     {
         const QString value = "newDescription";
         QSignalSpy spy(course.get(), SIGNAL(descriptionChanged()));
         QCOMPARE(spy.count(), 0);
         course->setDescription(value);
         QCOMPARE(course->description(), value);
         QCOMPARE(spy.count(), 1);
     }
 
     // language
     {
         std::shared_ptr<Language> testLanguage;
         QSignalSpy spy(course.get(), SIGNAL(languageChanged()));
         QCOMPARE(spy.count(), 0);
         course->setLanguage(testLanguage);
         QCOMPARE(course->language(), testLanguage);
         QCOMPARE(spy.count(), 1);
     }
 }
 
 void TestEditableCourseResource::fileLoadSaveCompleteness()
 {
     // boilerplate
     std::shared_ptr<ILanguage> language(new LanguageStub("de"));
     ResourceRepositoryStub repository({language});
     auto course = EditableCourseResource::create(QUrl::fromLocalFile(":/courses/de.xml"), &repository);
 
     QTemporaryFile outputFile;
     outputFile.open();
     course->exportToFile(QUrl::fromLocalFile(outputFile.fileName()));
 
     // note: this only works, since the resource manager not checks uniqueness of course ids!
     auto loadedCourse = EditableCourseResource::create(QUrl::fromLocalFile(outputFile.fileName()), &repository);
 
     // test that we actually call the different files
     QVERIFY(course->file().toLocalFile() != loadedCourse->file().toLocalFile());
     QVERIFY(course->id() == loadedCourse->id());
     QVERIFY(course->foreignId() == loadedCourse->foreignId());
     QVERIFY(course->title() == loadedCourse->title());
     QVERIFY(course->description() == loadedCourse->description());
     QVERIFY(course->language()->id() == loadedCourse->language()->id());
     QVERIFY(course->units().count() == loadedCourse->units().count());
 
     auto testUnit = course->units().constFirst();
     auto compareUnit = loadedCourse->units().constFirst();
     QVERIFY(testUnit->id() == compareUnit->id());
     QVERIFY(testUnit->foreignId() == compareUnit->foreignId());
     QVERIFY(testUnit->title() == compareUnit->title());
-    QVERIFY(testUnit->phrases().count() == compareUnit->phrases().count());
+    QCOMPARE(testUnit->phrases().count(), compareUnit->phrases().count());
 
     std::shared_ptr<IPhrase> testPhrase = testUnit->phrases().constFirst();
     std::shared_ptr<IPhrase> comparePhrase = Phrase::create();
     // note that this actually means that we DO NOT respect phrase orders by list order
     for (const auto &phrase : compareUnit->phrases()) {
         if (testPhrase->id() == phrase->id()) {
             comparePhrase = phrase;
             break;
         }
     }
     QVERIFY(testPhrase->id() == comparePhrase->id());
     QVERIFY(testPhrase->foreignId() == comparePhrase->foreignId());
     QVERIFY(testPhrase->text() == comparePhrase->text());
     QVERIFY(testPhrase->type() == comparePhrase->type());
     QVERIFY(testPhrase->sound().fileName() == comparePhrase->sound().fileName());
     QVERIFY(testPhrase->phonemes().count() == comparePhrase->phonemes().count());
 }
 
 void TestEditableCourseResource::modifiedStatus()
 {
     // boilerplate
     std::shared_ptr<ILanguage> language(new LanguageStub("de"));
     ResourceRepositoryStub repository({language});
     auto course = EditableCourseResource::create(QUrl::fromLocalFile(":/courses/de.xml"), &repository);
 
     { // initial file loading
         QTemporaryFile outputFile;
         outputFile.open();
         course->exportToFile(QUrl::fromLocalFile(outputFile.fileName()));
         auto loadedCourse = EditableCourseResource::create(QUrl::fromLocalFile(outputFile.fileName()), &repository);
         QCOMPARE(loadedCourse->isModified(), false);
     }
 
     { // set ID
         QTemporaryFile outputFile;
         outputFile.open();
         course->exportToFile(QUrl::fromLocalFile(outputFile.fileName()));
         auto loadedCourse = EditableCourseResource::create(QUrl::fromLocalFile(outputFile.fileName()), &repository);
         QCOMPARE(loadedCourse->isModified(), false);
         loadedCourse->setId("ASDF");
         QCOMPARE(loadedCourse->isModified(), true);
         loadedCourse->sync();
         QCOMPARE(loadedCourse->isModified(), false);
     }
 
     { // set title
         QTemporaryFile outputFile;
         outputFile.open();
         course->exportToFile(QUrl::fromLocalFile(outputFile.fileName()));
         auto loadedCourse = EditableCourseResource::create(QUrl::fromLocalFile(outputFile.fileName()), &repository);
         QCOMPARE(loadedCourse->isModified(), false);
         loadedCourse->setTitle("ASDF");
         QCOMPARE(loadedCourse->isModified(), true);
         loadedCourse->sync();
         QCOMPARE(loadedCourse->isModified(), false);
     }
 
     { // set i18n title
         QTemporaryFile outputFile;
         outputFile.open();
         course->exportToFile(QUrl::fromLocalFile(outputFile.fileName()));
         auto loadedCourse = EditableCourseResource::create(QUrl::fromLocalFile(outputFile.fileName()), &repository);
         QCOMPARE(loadedCourse->isModified(), false);
         loadedCourse->setI18nTitle("ASDF");
         QCOMPARE(loadedCourse->isModified(), true);
         loadedCourse->sync();
         QCOMPARE(loadedCourse->isModified(), false);
     }
 
     { // set description
         QTemporaryFile outputFile;
         outputFile.open();
         course->exportToFile(QUrl::fromLocalFile(outputFile.fileName()));
         auto loadedCourse = EditableCourseResource::create(QUrl::fromLocalFile(outputFile.fileName()), &repository);
         QCOMPARE(loadedCourse->isModified(), false);
         loadedCourse->setDescription("ASDF");
         QCOMPARE(loadedCourse->isModified(), true);
         loadedCourse->sync();
         QCOMPARE(loadedCourse->isModified(), false);
     }
 
     { // set language
         QTemporaryFile outputFile;
         outputFile.open();
         course->exportToFile(QUrl::fromLocalFile(outputFile.fileName()));
         auto loadedCourse = EditableCourseResource::create(QUrl::fromLocalFile(outputFile.fileName()), &repository);
         QCOMPARE(loadedCourse->isModified(), false);
         std::shared_ptr<ILanguage> newLanguage(new LanguageStub("en"));
         loadedCourse->setLanguage(newLanguage);
         QCOMPARE(loadedCourse->isModified(), true);
         loadedCourse->sync();
         QCOMPARE(loadedCourse->isModified(), false);
     }
 
     { // add unit
         QTemporaryFile outputFile;
         outputFile.open();
         course->exportToFile(QUrl::fromLocalFile(outputFile.fileName()));
         auto loadedCourse = EditableCourseResource::create(QUrl::fromLocalFile(outputFile.fileName()), &repository);
         QCOMPARE(loadedCourse->isModified(), false);
         auto unit = Unit::create();
         unit->setId("testunit");
         loadedCourse->addUnit(std::move(unit));
         QCOMPARE(loadedCourse->isModified(), true);
         loadedCourse->sync();
         QCOMPARE(loadedCourse->isModified(), false);
     }
 }
 
 void TestEditableCourseResource::skeletonUpdate()
 {
     std::shared_ptr<ILanguage> language(new LanguageStub("de"));
     ResourceRepositoryStub repository({language});
     auto course = EditableCourseResource::create(QUrl::fromLocalFile(":/courses/de.xml"), &repository);
     QCOMPARE(course->units().count(), 1);
 
     // create skeleton stub
     auto importPhrase = Phrase::create();
     importPhrase->setId("importPhraseId");
     importPhrase->setText("phraseText");
     importPhrase->setType(IPhrase::Type::Sentence);
     auto importUnit = Unit::create();
     importUnit->setId("importId");
     importUnit->addPhrase(importPhrase);
     auto skeleton = CourseStub::create(language, {importUnit});
 
     // test import
     course->updateFrom(skeleton);
     QCOMPARE(course->units().count(), 2);
     {
         std::shared_ptr<Unit> importedUnit;
         for (auto unit : course->units()) {
             if (unit->foreignId() == importUnit->id()) {
                 importedUnit = unit;
                 break;
             }
         }
         QVERIFY(importedUnit != nullptr);
         QCOMPARE(importedUnit->foreignId(), importUnit->id());
         QCOMPARE(importedUnit->id(), importUnit->id());
         QCOMPARE(importedUnit->title(), importUnit->title());
         QCOMPARE(importedUnit->phrases().count(), 1);
         auto importedPhrase = importedUnit->phrases().first();
         QCOMPARE(importedPhrase->id(), importPhrase->id());
         QCOMPARE(importedPhrase->foreignId(), importPhrase->id());
         QCOMPARE(importedPhrase->text(), importPhrase->text());
         QCOMPARE(importedPhrase->type(), importPhrase->type());
     }
 
     // test that re-import does not change course
     course->updateFrom(skeleton);
     QCOMPARE(course->units().count(), 2);
 }
 
 QTEST_GUILESS_MAIN(TestEditableCourseResource)
diff --git a/src/core/resources/courseresource.cpp b/src/core/resources/courseresource.cpp
index a5adc0e..55f428f 100644
--- a/src/core/resources/courseresource.cpp
+++ b/src/core/resources/courseresource.cpp
@@ -1,285 +1,287 @@
 /*
  *  Copyright 2013-2015  Andreas Cord-Landwehr <cordlandwehr@kde.org>
  *  Copyright 2013       Oindrila Gupta <oindrila.gupta92@gmail.com>
  *
  *  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 2 of
  *  the License or (at your option) version 3 or any later version
  *  accepted by the membership of KDE e.V. (or its successor approved
  *  by the membership of KDE e.V.), which shall act as a proxy
  *  defined in Section 14 of version 3 of the license.
  *
  *  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/>.
  */
 
 #include "courseresource.h"
 #include "courseparser.h"
 #include "core/language.h"
 #include "core/unit.h"
 #include "core/phoneme.h"
 #include "core/phonemegroup.h"
 #include "core/iresourcerepository.h"
 
 #include <memory>
 #include <QQmlEngine>
 #include <QXmlSchema>
 #include <QXmlStreamReader>
 #include <QDomDocument>
 #include <QFile>
 #include <QFileInfo>
 #include <QDir>
 
 #include "artikulate_debug.h"
 
 class CourseResourcePrivate
 {
 public:
     CourseResourcePrivate() = default;
     ~CourseResourcePrivate();
 
     void loadCourse(CourseResource *parent);
 
     std::weak_ptr<ICourse> m_self;
     IResourceRepository *m_repository{ nullptr };
     QUrl m_file;
     QString m_identifier;
     QString m_foreignId;
     QString m_title;
     QString m_languageId;
     std::shared_ptr<ILanguage> m_language;
     QString m_i18nTitle;
     QString m_description;
     QVector<std::shared_ptr<Unit>> m_units;
     bool m_courseLoaded{ false }; ///<! indicates if course was completely parsed
 };
 
 CourseResourcePrivate::~CourseResourcePrivate() = default;
 
 void CourseResourcePrivate::loadCourse(CourseResource *parent)
 {
     if (m_courseLoaded == true) {
         qCWarning(ARTIKULATE_CORE()) << "Skipping loading of course, no reloading implemented yet";
         return;
     }
     m_courseLoaded = true;
 
     QFileInfo info(m_file.toLocalFile());
     if (!info.exists()) {
         qCCritical(ARTIKULATE_CORE()) << "No course file available at location" << m_file.toLocalFile();
         return;
     }
 
     QVector<std::shared_ptr<Phoneme>> phonemes = m_language->phonemes();
     auto units = CourseParser::parseUnits(m_file, phonemes);
     for (auto &unit : units) {
         parent->addUnit(std::move(unit));
     }
 }
 
 std::shared_ptr<CourseResource> CourseResource::create(const QUrl &path, IResourceRepository *repository)
 {
     std::shared_ptr<CourseResource> course(new CourseResource(path, repository));
     course->setSelf(course);
     return course;
 }
 
 void CourseResource::setSelf(std::shared_ptr<ICourse> self)
 {
+    Q_ASSERT(d->m_self.expired());
     d->m_self = self;
 }
 
 std::shared_ptr<ICourse> CourseResource::self() const
 {
+    Q_ASSERT(!d->m_self.expired());
     return d->m_self.lock();
 }
 
 CourseResource::CourseResource(const QUrl &path, IResourceRepository *repository)
     : ICourse()
     , d(new CourseResourcePrivate())
 {
     QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);
     d->m_file = path;
     d->m_repository = repository;
 
     // load basic information from language file, but does not parse everything
     QXmlStreamReader xml;
     QFile file(path.toLocalFile());
     if (file.open(QIODevice::ReadOnly)) {
         xml.setDevice(&file);
         xml.readNextStartElement();
         while (xml.readNext() && !xml.atEnd()) {
             if (xml.name() == "id") {
                 d->m_identifier = xml.readElementText();
                 continue;
             }
             if (xml.name() == "foreignId") {
                 d->m_foreignId = xml.readElementText();
                 continue;
             }
             //TODO i18nTitle must be implemented, currently missing and hence not parsed
             if (xml.name() == "title") {
                 d->m_title = xml.readElementText();
                 d->m_i18nTitle = d->m_title;
                 continue;
             }
             if (xml.name() == "description") {
                 d->m_description = xml.readElementText();
                 continue;
             }
             if (xml.name() == "language") {
                 d->m_languageId = xml.readElementText();
                 continue;
             }
 
             // quit reading when basic elements are read
             if (!d->m_identifier.isEmpty()
                 && !d->m_title.isEmpty()
                 && !d->m_i18nTitle.isEmpty()
                 && !d->m_description.isEmpty()
                 && !d->m_languageId.isEmpty()
                 && !d->m_foreignId.isEmpty()
             )
             {
                 break;
             }
         }
         if (xml.hasError()) {
             qCritical() << "Error occurred when reading Course XML file:" << path.toLocalFile();
         }
     } else {
         qCCritical(ARTIKULATE_CORE()) << "Could not open course file" << path.toLocalFile();
     }
     xml.clear();
     file.close();
 
     // find correct language
     if (repository != nullptr) {
         for (const auto &language : repository->languages()) {
             if (language == nullptr) {
                 continue;
             }
             if (language->id() == d->m_languageId) {
                 d->m_language = language;
             }
         }
     }
     if (d->m_language == nullptr) {
         qCCritical(ARTIKULATE_CORE()) << "A course with an unknown language was loaded";
     }
 }
 
 CourseResource::~CourseResource() = default;
 
 QString CourseResource::id() const
 {
     return d->m_identifier;
 }
 
 void CourseResource::setId(const QString &id)
 {
     if (d->m_identifier == id) {
         return;
     }
     d->m_identifier = id;
     emit idChanged();
 }
 
 QString CourseResource::foreignId() const
 {
     return d->m_foreignId;
 }
 
 void CourseResource::setForeignId(const QString &foreignId)
 {
     if (d->m_foreignId == foreignId) {
         return;
     }
     d->m_foreignId = foreignId;
     emit foreignIdChanged();
 }
 
 QString CourseResource::title() const
 {
     return d->m_title;
 }
 
 void CourseResource::setTitle(const QString &title)
 {
     if (d->m_title == title) {
         return;
     }
     d->m_title = title;
     emit titleChanged();
 }
 
 QString CourseResource::i18nTitle() const
 {
     return d->m_i18nTitle;
 }
 
 void CourseResource::setI18nTitle(const QString &i18nTitle)
 {
     if (d->m_i18nTitle == i18nTitle) {
         return;
     }
     d->m_i18nTitle = i18nTitle;
     emit i18nTitleChanged();
 }
 
 QString CourseResource::description() const
 {
     return d->m_description;
 }
 
 void CourseResource::setDescription(const QString &description)
 {
     if (d->m_description == description) {
         return;
     }
     d->m_description = description;
     emit descriptionChanged();
 }
 
 std::shared_ptr<ILanguage> CourseResource::language() const
 {
     return d->m_language;
 }
 
 void CourseResource::setLanguage(std::shared_ptr<ILanguage> language)
 {
     if (d->m_language == language) {
         return;
     }
     d->m_language = language;
     emit languageChanged();
 }
 
 std::shared_ptr<Unit> CourseResource::addUnit(std::shared_ptr<Unit> unit)
 {
     std::shared_ptr<Unit> storedUnit(std::move(unit));
     storedUnit->setCourse(self());
     emit unitAboutToBeAdded(storedUnit, d->m_units.count() - 1);
     d->m_units.append(storedUnit);
     emit unitAdded();
     return storedUnit;
 }
 
 QVector<std::shared_ptr<Unit>> CourseResource::units()
 {
     if (d->m_courseLoaded == false) {
         d->loadCourse(this);
     }
     return d->m_units;
 }
 
 QUrl CourseResource::file() const
 {
     return d->m_file;
 }
diff --git a/src/core/resources/editablecourseresource.cpp b/src/core/resources/editablecourseresource.cpp
index 437571f..3a844b3 100644
--- a/src/core/resources/editablecourseresource.cpp
+++ b/src/core/resources/editablecourseresource.cpp
@@ -1,288 +1,288 @@
 /*
  *  Copyright 2019  Andreas Cord-Landwehr <cordlandwehr@kde.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 2 of
  *  the License or (at your option) version 3 or any later version
  *  accepted by the membership of KDE e.V. (or its successor approved
  *  by the membership of KDE e.V.), which shall act as a proxy
  *  defined in Section 14 of version 3 of the license.
  *
  *  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/>.
  */
 
 #include "editablecourseresource.h"
 #include "artikulate_debug.h"
 #include "core/phoneme.h"
 #include "core/phrase.h"
 #include "core/unit.h"
 #include "courseparser.h"
 #include <memory>
 #include <KLocalizedString>
 #include <KTar>
 #include <QDir>
 #include <QDomDocument>
 #include <QFile>
 #include <QFileInfo>
 #include <QObject>
 #include <QQmlEngine>
 #include <QUuid>
 
 EditableCourseResource::EditableCourseResource(const QUrl &path, IResourceRepository *repository)
     : IEditableCourse()
     , m_course(new CourseResource(path, repository))
 {
     QQmlEngine::setObjectOwnership(this, QQmlEngine::CppOwnership);
 
-    for (auto unit : m_course->units()) {
-        unit->setCourse(self());
-    }
-
     connect(m_course.get(), &ICourse::unitAboutToBeAdded, this, &ICourse::unitAboutToBeAdded);
     connect(m_course.get(), &ICourse::unitAdded, this, &ICourse::unitAdded);
     connect(m_course.get(), &CourseResource::idChanged, this, &EditableCourseResource::idChanged);
     connect(m_course.get(), &CourseResource::foreignIdChanged, this,
         &EditableCourseResource::foreignIdChanged);
     connect(
         m_course.get(), &CourseResource::titleChanged, this, &EditableCourseResource::titleChanged);
     connect(m_course.get(), &CourseResource::descriptionChanged, this,
         &EditableCourseResource::descriptionChanged);
     connect(m_course.get(), &CourseResource::languageChanged, this,
         &EditableCourseResource::languageChanged);
 }
 
 std::shared_ptr<EditableCourseResource> EditableCourseResource::create(
     const QUrl &path, IResourceRepository *repository)
 {
     std::shared_ptr<EditableCourseResource> course(new EditableCourseResource(path, repository));
     course->setSelf(course);
+    for (auto &unit : course->units()) {
+        unit->setCourse(course);
+    }
+
     return course;
 }
 
 void EditableCourseResource::setSelf(std::shared_ptr<ICourse> self)
 {
     m_course->setSelf(self);
 }
 
 QString EditableCourseResource::id() const
 {
     return m_course->id();
 }
 
 void EditableCourseResource::setId(QString id)
 {
     if (m_course->id() != id) {
         m_course->setId(id);
         m_modified = true;
     }
 }
 
 QString EditableCourseResource::foreignId() const { return m_course->foreignId(); }
 
 void EditableCourseResource::setForeignId(QString foreignId)
 {
     m_course->setForeignId(std::move(foreignId));
 }
 
 QString EditableCourseResource::title() const { return m_course->title(); }
 
 void EditableCourseResource::setTitle(QString title)
 {
     if (m_course->title() != title) {
         m_course->setTitle(title);
         m_modified = true;
     }
 }
 
 QString EditableCourseResource::i18nTitle() const { return m_course->i18nTitle(); }
 
 void EditableCourseResource::setI18nTitle(QString i18nTitle)
 {
     if (m_course->i18nTitle() != i18nTitle) {
         m_course->setI18nTitle(i18nTitle);
         m_modified = true;
     }
 }
 
 QString EditableCourseResource::description() const { return m_course->description(); }
 
 void EditableCourseResource::setDescription(QString description)
 {
     if (m_course->description() != description) {
         m_course->setDescription(description);
         m_modified = true;
     }
 }
 
 std::shared_ptr<ILanguage> EditableCourseResource::language() const { return m_course->language(); }
 
 void EditableCourseResource::setLanguage(std::shared_ptr<ILanguage> language)
 {
     if (m_course->language() != language) {
         m_course->setLanguage(language);
         m_modified = true;
     }
 }
 
 QUrl EditableCourseResource::file() const
 {
     return m_course->file();
 }
 
 std::shared_ptr<IEditableCourse> EditableCourseResource::self() const
 {
     return std::static_pointer_cast<IEditableCourse>(m_course->self());
 }
 
 bool EditableCourseResource::sync()
 {
     Q_ASSERT(file().isValid());
     Q_ASSERT(file().isLocalFile());
     Q_ASSERT(!file().isEmpty());
 
     // not writing back if not modified
     if (!m_modified) {
         qCDebug(ARTIKULATE_LOG()) << "Aborting sync, course was not modified.";
         return false;
     }
     bool ok = exportToFile(file());
     if (ok) {
         m_modified = false;
     }
     return ok;
 }
 
 bool EditableCourseResource::exportToFile(const QUrl &filePath) const
 {
     // write back to file
     // create directories if necessary
     QFileInfo info(filePath.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path());
     if (!info.exists()) {
         qCDebug(ARTIKULATE_LOG()) << "create xml output file directory, not existing";
         QDir dir;
         dir.mkpath(filePath.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path());
     }
 
     // TODO port to KSaveFile
     QFile file(filePath.toLocalFile());
     if (!file.open(QIODevice::WriteOnly)) {
         qCWarning(ARTIKULATE_LOG())
             << "Unable to open file " << file.fileName() << " in write mode, aborting.";
         return false;
     }
 
     file.write(CourseParser::serializedDocument(m_course.get(), false).toByteArray());
     return true;
 }
 
 std::shared_ptr<Unit> EditableCourseResource::addUnit(std::shared_ptr<Unit> unit)
 {
     m_modified = true;
     auto sharedUnit = m_course->addUnit(std::move(unit));
     sharedUnit->setCourse(self());
     return sharedUnit;
 }
 
 QVector<std::shared_ptr<Unit>> EditableCourseResource::units() { return m_course->units(); }
 
 void EditableCourseResource::updateFrom(std::shared_ptr<ICourse> skeleton)
 {
     for (auto skeletonUnit : skeleton->units()) {
 
         // find matching unit or create one
         std::shared_ptr<Unit> matchingUnit;
         auto it = std::find_if(m_course->units().cbegin(), m_course->units().cend(),
             [skeletonUnit](std::shared_ptr<Unit> compareUnit) {
                 return compareUnit->foreignId() == skeletonUnit->id();
             });
         if (it == m_course->units().cend()) {
             // import complete unit
             auto importUnit = Unit::create();
             importUnit->setId(skeletonUnit->id());
             importUnit->setForeignId(skeletonUnit->id());
             importUnit->setTitle(skeletonUnit->title());
             matchingUnit = m_course->addUnit(std::move(importUnit));
         } else {
             matchingUnit = *it;
         }
 
         // import phrases
         for (auto skeletonPhrase : skeletonUnit->phrases()) {
             auto it = std::find_if(matchingUnit->phrases().cbegin(),
                 matchingUnit->phrases().cend(), [skeletonPhrase](std::shared_ptr<IPhrase> comparePhrase) {
                     return comparePhrase->foreignId() == skeletonPhrase->id();
                 });
             if (it == matchingUnit->phrases().cend()) {
                 // import complete Phrase
                 std::shared_ptr<Phrase> importPhrase = Phrase::create();
                 importPhrase->setId(skeletonPhrase->id());
                 importPhrase->setForeignId(skeletonPhrase->id());
                 importPhrase->setText(skeletonPhrase->text());
                 importPhrase->seti18nText(skeletonPhrase->i18nText());
                 importPhrase->setType(skeletonPhrase->type());
                 importPhrase->setUnit(matchingUnit);
                 matchingUnit->addPhrase(importPhrase);
             }
         }
     }
 
     qCInfo(ARTIKULATE_LOG()) << "Update performed!";
 }
 
 bool EditableCourseResource::isModified() const { return m_modified; }
 
 Unit *EditableCourseResource::createUnit()
 {
     // find first unused id
     QStringList unitIds;
     for (auto unit : m_course->units()) {
         unitIds.append(unit->id());
     }
     QString id = QUuid::createUuid().toString();
     while (unitIds.contains(id)) {
         id = QUuid::createUuid().toString();
         qCWarning(ARTIKULATE_LOG) << "Unit id generator has found a collision, recreating id.";
     }
 
     // create unit
     std::shared_ptr<Unit> unit = Unit::create();
     unit->setCourse(self());
     unit->setId(id);
     unit->setTitle(i18n("New Unit"));
     auto sharedUnit = addUnit(std::move(unit));
 
     return sharedUnit.get();
 }
 
 std::shared_ptr<Phrase> EditableCourseResource::createPhrase(Unit *unit)
 {
     // find globally unique phrase id inside course
     QStringList phraseIds;
     for (auto unit : m_course->units()) {
         for (auto &phrase : unit->phrases()) {
             phraseIds.append(phrase->id());
         }
     }
     QString id = QUuid::createUuid().toString();
     while (phraseIds.contains(id)) {
         id = QUuid::createUuid().toString();
         qCWarning(ARTIKULATE_LOG) << "Phrase id generator has found a collision, recreating id.";
     }
 
     // create unit
     std::shared_ptr<Phrase> phrase = Phrase::create();
     phrase->setId(id);
     phrase->setText(QLatin1String(""));
     phrase->setType(IPhrase::Type::Word);
 
     unit->addPhrase(phrase);
 
     return phrase;
 }