const dbUtils = global.dbUtils;

module.exports = {
    song: {
        insertCollection: async (songInfoList) => {
            if (songInfoList.length == 0) return;
            // image 因为接口没有返回，所以不更新
            let result = await dbUtils.query(`
                INSERT INTO song (
                    song_id, title, type, alias, pop, fee, quality, cd,
                    no, dj_id, s_id, origin_cover_type, pub_time,
                    no_copyright_rcmd, mv, single, version, data_version
                ) VALUES ? ON DUPLICATE KEY UPDATE
                    title = VALUES(title), type = VALUES(type), alias = VALUES(alias), pop = VALUES(pop), fee = VALUES(fee), quality = VALUES(quality), cd = VALUES(cd),
                    no = VALUES(no), dj_id = VALUES(dj_id), s_id = VALUES(s_id), origin_cover_type = VALUES(origin_cover_type), pub_time = VALUES(pub_time),
                    no_copyright_rcmd = VALUES(no_copyright_rcmd), mv = VALUES(mv), single = VALUES(single), version = VALUES(version), data_version = VALUES(data_version)
            `, [songInfoList.map(songInfo => [
                songInfo.id, songInfo.title, songInfo.type, songInfo.alias, songInfo.pop, songInfo.fee, songInfo.quality, songInfo.cd,
                songInfo.no, songInfo.djId, songInfo.sId, songInfo.originCoverType, songInfo.pubTime,
                songInfo.noCopyrightRcmd, songInfo.mv, songInfo.single, songInfo.version, 2
            ])]);
            await dbUtils.query(`
                DELETE FROM wait_fetch_song WHERE id IN ?
            `, [[songInfoList.map(songInfo => songInfo.id)]])
            return result;
        },

        getIdsToFetch: async (args) => {
            let whereClause = [
                args.min ? `id >  ${args.min}` : '1=1',
                args.max ? `id <= ${args.max}` : '1=1',
            ].join(' AND ');
            let sql = `
                SELECT id FROM wait_fetch_song WHERE ${whereClause}
                ${args.order ? `ORDER BY id ${args.order}` : ''}
                ${args.limit ? `LIMIT ${args.limit}` : ''}
            `;
            // 更新现有数据
            // sql = `SELECT song_id FROM song WHERE data_version = 1`;
            console.log(sql);
            let songIds = await dbUtils.query(sql, []);
            songIds = songIds.map(item => item.id);
            return songIds;
        },
    },


    album: {
        insert: async (albumInfo) => {
            return await dbUtils.query('INSERT IGNORE INTO album SET ?', albumInfo);
        },

        update: async (albumId, albumInfo) => {
            return await dbUtils.query(`UPDATE album SET ? WHERE album_id = ${albumId}`, albumInfo);
        },

        getIdsToFetch: async (args, isUpdate) => {
            let sql = "";
            if (isUpdate) {
                sql = `SELECT album_id FROM album WHERE (full_description = '' or full_description is null) and description like '%专辑《%》，简介：%' and description not regexp '^.*?专辑《.*?》，简介：[:space:]*?。，更多.*$'`;
            } else {
                let whereClause = [
                    args.min ? `id >  ${args.min}` : '1=1',
                    args.max ? `id <= ${args.max}` : '1=1',
                ].join(' AND ');
                sql = `
                    SELECT id FROM wait_fetch_album WHERE ${whereClause}
                    ${args.order ? `ORDER BY id ${args.order}` : ''}
                    ${args.limit ? `LIMIT ${args.limit}` : ''}
                `;
            }
            console.log(sql);
            let albumIds = await dbUtils.query(sql, []);
            albumIds = albumIds.map(item => item.id);
            return albumIds;
        },

        getInfoById: async (albumId, { getRelation = true }) => {
            if (!albumId) return {}
            // 查询出专辑
            const sql = 'SELECT * FROM album WHERE album_id = ?'
            let infoResultSet = await dbUtils.query(sql, [albumId]);
            if (infoResultSet.length == 0) return {};
            let albumInfo = JSON.parse(JSON.stringify(infoResultSet[0]));
            if (getRelation) {
                // 查出专辑与歌曲对应关系
                const sql2 = 'SELECT * FROM song_album_relation WHERE album_id = ?'
                let relationResultSet = await dbUtils.query(sql2, [albumId]);
                // 拼装
                albumInfo.songIds = relationResultSet.map(song => song.song_id);
            } else {
                albumInfo.songIds = null;
            }
            return albumInfo;
        },
    },


    artist: {
        insert: async (artistInfo) => {
            return await dbUtils.query('INSERT IGNORE INTO artist SET ?', artistInfo);
        },

        getIdsToFetch: async (args) => {
            let whereClause = [
                args.min ? `id >  ${args.min}` : '1=1',
                args.max ? `id <= ${args.max}` : '1=1',
            ].join(' AND ');
            let sql = `
                SELECT id FROM wait_fetch_artist WHERE ${whereClause}
                ${args.order ? `ORDER BY id ${args.order}` : ''}
                ${args.limit ? `LIMIT ${args.limit}` : ''}
            `;
            console.log(sql);
            let artistIds = await dbUtils.query(sql, []);
            artistIds = artistIds.map(item => item.id);
            return artistIds;
        },

        getInfoById: async (artistId, { getRelation = true }) => {
            if (!artistId) return {}
            // 查询出歌手
            const sql = 'SELECT * FROM artist WHERE artist_id = ?'
            let infoResultSet = await dbUtils.query(sql, [artistId]);
            if (infoResultSet.length == 0) return {};
            let artistInfo = JSON.parse(JSON.stringify(infoResultSet[0]));
            if (getRelation) {
                // 查出歌手与歌曲对应关系
                const sql2 = 'SELECT * FROM song_artist_relation WHERE artist_id = ?'
                let relationResultSet = await dbUtils.query(sql2, [artistId]);
                // 拼装
                artistInfo.songIds = relationResultSet.map(song => song.song_id);
            } else {
                artistInfo.songIds = null;
            }
            return artistInfo;
        },
    },


    lyric: {
        insert: async (lyricInfo) => {
            return await dbUtils.query('INSERT IGNORE INTO lyric SET ?', lyricInfo);
        },

        getIdsToFetch: async (args) => {
            let whereClause = [
                args.min ? `id >  ${args.min}` : '1=1',
                args.max ? `id <= ${args.max}` : '1=1',
            ].join(' AND ');
            var sql = `
                SELECT id FROM wait_fetch_lyric WHERE ${whereClause}
                ${args.order ? `ORDER BY id ${args.order}` : ''}
                ${args.limit ? `LIMIT ${args.limit}` : ''}
            `;
            console.log(sql);
            let songIds = await dbUtils.query(sql, []);
            songIds = songIds.map(item => item.id);
            return songIds;
        },
    },


    comment: {
        insertCollection: async (commentInfoList) => {
            if (commentInfoList.length == 0) return;
            return await dbUtils.query(`
                INSERT INTO comment ( comment_id, parent_comment_id, user_id, song_id, content, time, like_count, comment_type ) VALUES ?
                ON DUPLICATE KEY UPDATE content = VALUES(content), like_count = VALUES(like_count), comment_type = GREATEST(comment_type, VALUES(comment_type)), modify_time = CURRENT_TIMESTAMP
            `, [commentInfoList]);
        },

        getIdsToFetch: async (args) => {
            let whereClause = [
                args.min ? `song_id >  ${args.min}` : '1=1',
                args.max ? `song_id <= ${args.max}` : '1=1',
            ].join(' AND ');
            var sql = `
                SELECT song_id FROM comment_progress WHERE ${whereClause} AND current_status != 2
                ORDER BY current_status DESC${args.order ? `, song_id ${args.order}` : ''}
                ${args.limit ? `LIMIT ${args.limit}` : ''}
            `;
            console.log(sql);
            let songIds = await dbUtils.query(sql, []);
            songIds = songIds.map(item => item.song_id);
            return songIds;
        },
    },


    comment_progress: {
        update: async (commentProgressInfo, songId) => {
            return await dbUtils.query('UPDATE comment_progress SET ? WHERE song_id = ? LIMIT 1', [commentProgressInfo, songId]);
        },
    },


    playlist: {
        insertCollection: async (playlistInfo) => {
            if (playlistInfo.length == 0) return;
            return await dbUtils.query(`
                INSERT INTO playlist ( ${Object.keys(playlistInfo).map(field => `\`${field}\``).join(",")} ) VALUES ?
                ON DUPLICATE KEY UPDATE ${Object.keys(playlistInfo).map(field => `${field}=VALUES(${field})`).join(", ")}
            `, [[Object.values(playlistInfo)]]);
        },
    },


    user: {
        insertCollection: async (userInfoList) => {
            if (userInfoList.length == 0) return;
            return await dbUtils.query(`
                INSERT INTO user ( user_id, user_type, nickname, avatar_url ) VALUES ?
                ON DUPLICATE KEY UPDATE user_type = VALUES(user_type), nickname = VALUES(nickname), avatar_url = VALUES(avatar_url), modify_time = CURRENT_TIMESTAMP
            `, [userInfoList]);
        },
    },


    song_album: {
        insertCollection: async (songAlbumRel) => {
            if (songAlbumRel.length == 0) return;
            return await dbUtils.query('INSERT IGNORE INTO song_album_relation (song_id, album_id) VALUES ?', [songAlbumRel]);
        },
    },


    song_artist: {
        insertCollection: async (songArtistRel) => {
            if (songArtistRel.length == 0) return;
            return await dbUtils.query('INSERT IGNORE INTO song_artist_relation (song_id, artist_id) VALUES ?', [songArtistRel]);
        },
    },


    song_playlist: {
        insertCollection: async (trackIds) => {
            if (trackIds.length == 0) return;
            return await dbUtils.query('INSERT IGNORE INTO song_playlist_relation (song_id, playlist_id, alg) VALUES ?', [trackIds]);
        },
    },


    /* ##################################################### */


    // 将 id 插入待检查表
    wait_check: {
        insert: async (type, ids) => {
            // 过滤掉 id 为 0 的
            ids = ids.filter(id => id > 0);
            if (ids.length == 0) return;
            return await dbUtils.query(`INSERT IGNORE INTO wait_check_${type} (id) VALUES ?`, [ids.map(id => [id])]);
        },
    },

    wait_fetch: {
        deleteCollection: async function (type, ids) {
            // console.log("wait_fetch.deleteCollection", type, ids);
            if (ids.length > 0)
                return await dbUtils.query(`DELETE FROM wait_fetch_${type} WHERE id IN ?`, [[ids]]);
        }
    }
};