import eu.kanade.tachiyomi.source.model.UpdateStrategy;
import java.lang.String;
import kotlin.collections.List;

CREATE TABLE mangas(
    _id INTEGER NOT NULL PRIMARY KEY,
    source INTEGER NOT NULL,
    url TEXT NOT NULL,
    artist TEXT,
    author TEXT,
    description TEXT,
    genre TEXT AS List<String>,
    title TEXT NOT NULL,
    status INTEGER NOT NULL,
    thumbnail_url TEXT,
    favorite INTEGER AS Boolean NOT NULL,
    last_update INTEGER AS Long,
    next_update INTEGER AS Long,
    initialized INTEGER AS Boolean NOT NULL,
    viewer INTEGER NOT NULL,
    chapter_flags INTEGER NOT NULL,
    cover_last_modified INTEGER AS Long NOT NULL,
    date_added INTEGER AS Long NOT NULL,
    filtered_scanlators TEXT AS List<String>,
    update_strategy INTEGER AS UpdateStrategy NOT NULL DEFAULT 0
);

CREATE INDEX library_favorite_index ON mangas(favorite) WHERE favorite = 1;
CREATE INDEX mangas_url_index ON mangas(url);

getMangaById:
SELECT *
FROM mangas
WHERE _id = :id;

getMangaByUrlAndSource:
SELECT *
FROM mangas
WHERE url = :url AND source = :source;

getFavorites:
SELECT *
FROM mangas
WHERE favorite = 1;

getReadMangaNotInLibrary:
SELECT mangas.*
FROM mangas
WHERE favorite = 0 AND _id IN(
    SELECT chapters.manga_id FROM chapters WHERE read = 1 OR last_page_read != 0
);

getSourceIdWithFavoriteCount:
SELECT
source,
count(*)
FROM mangas
WHERE favorite = 1
GROUP BY source;

getFavoriteBySourceId:
SELECT *
FROM mangas
WHERE favorite = 1
AND source = :sourceId;

getDuplicateLibraryManga:
SELECT *
FROM mangas
WHERE favorite = 1
AND LOWER(title) = :title
AND source != :source
LIMIT 1;

resetViewerFlags:
UPDATE mangas
SET viewer = 0;

getSourceIdsWithNonLibraryManga:
SELECT source, COUNT(*) AS manga_count
FROM mangas
WHERE favorite = 0
GROUP BY source;

getLibrary:
SELECT M.*, COALESCE(MC.category_id, 0) AS category
FROM (
    SELECT mangas.*, COALESCE(UR.unreadCount, 0) AS unread_count, COALESCE(R.readCount, 0) AS read_count
    FROM mangas
    LEFT JOIN (
        SELECT chapters.manga_id, COUNT(*) AS unreadCount
        FROM chapters
        WHERE chapters.read = 0
        GROUP BY chapters.manga_id
    ) AS UR
    ON mangas._id = UR.manga_id
    LEFT JOIN (
        SELECT chapters.manga_id, COUNT(*) AS readCount
        FROM chapters
        WHERE chapters.read = 1
        GROUP BY chapters.manga_id
    ) AS R
    ON mangas._id = R.manga_id
    WHERE mangas.favorite = 1
    GROUP BY mangas._id
    ORDER BY mangas.title
) AS M
LEFT JOIN (
    SELECT *
    FROM mangas_categories
) AS MC
ON M._id = MC.manga_id;

getLastRead:
SELECT M.*, MAX(H.last_read) AS max
FROM mangas M
JOIN chapters C
ON M._id = C.manga_id
JOIN history H
ON C._id = H.chapter_id
WHERE M.favorite = 1
GROUP BY M._id
ORDER BY max ASC;

getLatestByChapterUploadDate:
SELECT M.*, MAX(C.date_upload) AS max
FROM mangas M
JOIN chapters C
ON M._id = C.manga_id
GROUP BY M._id
ORDER BY max ASC;

getLatestByChapterFetchDate:
SELECT M.*, MAX(C.date_fetch) AS max
FROM mangas M
JOIN chapters C
ON M._id = C.manga_id
GROUP BY M._id
ORDER BY max ASC;

deleteMangasNotInLibraryBySourceIds:
DELETE FROM mangas
WHERE favorite = 0 AND source IN :sourceIdsAND AND _id NOT IN (
    SELECT manga_id FROM merged WHERE manga_id != merge_id
);

deleteMangasNotInLibraryAndNotReadBySourceIds:
DELETE FROM mangas
WHERE favorite = 0 AND source IN :sourceIdsAND AND _id NOT IN (
    SELECT manga_id FROM merged WHERE manga_id != merge_id
) AND _id NOT IN (
    SELECT manga_id FROM chapters WHERE read = 1 OR last_page_read != 0
);

insert:
INSERT INTO mangas(source,url,artist,author,description,genre,title,status,thumbnail_url,favorite,last_update,next_update,initialized,viewer,chapter_flags,cover_last_modified,date_added,filtered_scanlators,update_strategy)
VALUES (:source,:url,:artist,:author,:description,:genre,:title,:status,:thumbnailUrl,:favorite,:lastUpdate,:nextUpdate,:initialized,:viewerFlags,:chapterFlags,:coverLastModified,:dateAdded,:filteredScanlators,:updateStrategy);

update:
UPDATE mangas SET
    source = coalesce(:source, source),
    url = coalesce(:url, url),
    artist = coalesce(:artist, artist),
    author = coalesce(:author, author),
    description = coalesce(:description, description),
    genre = coalesce(:genre, genre),
    title = coalesce(:title, title),
    status = coalesce(:status, status),
    thumbnail_url = coalesce(:thumbnailUrl, thumbnail_url),
    favorite = coalesce(:favorite, favorite),
    last_update = coalesce(:lastUpdate, last_update),
    initialized = coalesce(:initialized, initialized),
    viewer = coalesce(:viewer, viewer),
    chapter_flags = coalesce(:chapterFlags, chapter_flags),
    cover_last_modified = coalesce(:coverLastModified, cover_last_modified),
    date_added = coalesce(:dateAdded, date_added),
    filtered_scanlators = coalesce(:filteredScanlators, filtered_scanlators),
    update_strategy = coalesce(:updateStrategy, update_strategy)
WHERE _id = :mangaId;

selectLastInsertedRowId:
SELECT last_insert_rowid();

getEhMangaWithMetadata:
SELECT mangas.* FROM mangas
INNER JOIN search_metadata
    ON mangas._id = search_metadata.manga_id
WHERE mangas.favorite = 1 AND (mangas.source = :eh OR mangas.source = :exh);

getIdsOfFavoriteMangaWithMetadata:
SELECT mangas._id FROM mangas
INNER JOIN search_metadata
    ON mangas._id = search_metadata.manga_id
WHERE mangas.favorite = 1;

getBySource:
SELECT * FROM mangas WHERE source = :sourceId;

getAll:
SELECT * FROM mangas;

deleteById:
DELETE FROM mangas WHERE _id = :id;

selectLastInsertRow:
SELECT *
FROM mangas
WHERE _id = last_insert_rowid();

getIdByUrlAndSource:
SELECT _id
FROM mangas
WHERE url = :url AND source = :source;