const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const { parse } = require('csv-parse/sync');

const IMPORT_DIR = path.join(__dirname, 'import');
const SUCCESS_DIR = path.join(__dirname, 'success');
const FAIL_DIR = path.join(__dirname, 'fail');
const DEFAULT_TIME_ZONE = process.env.LW_TIMEZONE || 'Asia/Tokyo';
const REQUIRED_CSV_HEADERS = ['登録先', '開始日', '開始時刻', '終了日', '終了時刻', '分類', '予定', '備考'];

const LW_TOKEN_URL = 'https://auth.worksmobile.com/oauth2/v2.0/token';
const LW_API_BASE_URL = 'https://www.worksapis.com/v1.0';
const LW_EVENT_ENDPOINT_TEMPLATE = '/users/{userId}/calendar/events';
const PRIVATE_KEY_FILE = path.join(__dirname, 'private_20260306134304.key');
const LW_USER_LOOKUP_DOMAIN_ID = '401101389';

const LW_CLIENT_ID = 'tre8J_Tk8RblfsMSyZRh';
const LW_CLIENT_SECRET = 'O5_R5gcHxg';
const LW_SERVICE_ACCOUNT = 'wh4k8.serviceaccount@next-hd.co.jp';
const LW_PRIVATE_KEY = (fs.existsSync(PRIVATE_KEY_FILE) ? fs.readFileSync(PRIVATE_KEY_FILE, 'utf8') : '');
const LW_SCOPE = process.env.LW_SCOPE || 'calendar';
const LW_USER_LOOKUP_SCOPE = process.env.LW_USER_LOOKUP_SCOPE || 'user.read';
const LW_SEND_NOTIFICATION = process.env.LW_SEND_NOTIFICATION !== '0';
const LW_DRY_RUN = process.env.LW_DRY_RUN === '1';
// 本番に近い検証: 認証やデータ生成は実行し、API POSTのみ停止する
const LW_PRE_IMPORT_TEST = process.env.LW_PRE_IMPORT_TEST === '1';
const LW_RETRY_MAX = Number(process.env.LW_RETRY_MAX || '3');
// 1分辺り240回がリミットのため、指数関数的に待機時間を増やす場合のベース時間（ms）
const LW_RETRY_BASE_MS = Number(process.env.LW_RETRY_BASE_MS || '5000'); // 1分
const LW_API_WAIT_MS = Number(process.env.LW_API_WAIT_MS || '300'); // APIリクエスト間の最小待機時間（ms）

let lastApiRequestAt = 0;

function ensureRequiredEnv() {
    if (LW_DRY_RUN) {
        return;
    }

    const required = [
        ['LW_CLIENT_ID', LW_CLIENT_ID],
        ['LW_CLIENT_SECRET', LW_CLIENT_SECRET],
        ['LW_SERVICE_ACCOUNT', LW_SERVICE_ACCOUNT],
        ['LW_PRIVATE_KEY', LW_PRIVATE_KEY]
    ];

    const missing = required.filter(([, value]) => !value).map(([key]) => key);
    if (missing.length > 0) {
        if (missing.includes('LW_PRIVATE_KEY') && !fs.existsSync(PRIVATE_KEY_FILE)) {
            throw new Error(`秘密鍵が見つかりません: ${PRIVATE_KEY_FILE}`);
        }
        throw new Error(`環境変数が不足しています: ${missing.join(', ')}`);
    }
}

function base64UrlEncode(value) {
    return Buffer.from(value)
        .toString('base64')
        .replace(/=/g, '')
        .replace(/\+/g, '-')
        .replace(/\//g, '_');
}

function createJwtAssertion() {
    const now = Math.floor(Date.now() / 1000);
    const header = { alg: 'RS256', typ: 'JWT' };
    const payload = {
        iss: LW_CLIENT_ID,
        sub: LW_SERVICE_ACCOUNT,
        aud: LW_TOKEN_URL,
        iat: now,
        exp: now + 300
    };

    const encodedHeader = base64UrlEncode(JSON.stringify(header));
    const encodedPayload = base64UrlEncode(JSON.stringify(payload));
    const signingInput = `${encodedHeader}.${encodedPayload}`;

    const signer = crypto.createSign('RSA-SHA256');
    signer.update(signingInput);
    signer.end();

    const signature = signer
        .sign(LW_PRIVATE_KEY)
        .toString('base64')
        .replace(/=/g, '')
        .replace(/\+/g, '-')
        .replace(/\//g, '_');

    return `${signingInput}.${signature}`;
}

async function getAccessToken(scopeOverride = LW_SCOPE) {
    if (LW_DRY_RUN) {
        return 'dry-run-token';
    }

    const assertion = createJwtAssertion();
    const form = new URLSearchParams({
        grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
        assertion,
        client_id: LW_CLIENT_ID,
        client_secret: LW_CLIENT_SECRET,
        scope: scopeOverride
    });

    const response = await lwFetch(LW_TOKEN_URL, {
        method: 'POST',
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
        body: form
    });

    if (!response.ok) {
        const detail = await response.text();
        throw new Error(`アクセストークン取得失敗: ${response.status} ${detail}`);
    }

    const data = await response.json();
    if (!data.access_token) {
        throw new Error('アクセストークン取得失敗: access_token が返却されませんでした');
    }

    return data.access_token;
}

function normalizeUserId(rawUser) {
    const mapText = process.env.LW_USER_MAP_JSON;
    if (!mapText) {
        return rawUser;
    }

    try {
        const map = JSON.parse(mapText);
        return map[rawUser] || rawUser;
    } catch (error) {
        throw new Error(`LW_USER_MAP_JSON のJSON解析に失敗しました: ${error.message}`);
    }
}

function extractUserNameFromFilename(fileName) {
    const base = path.basename(fileName, path.extname(fileName));
    const matched = base.match(/^(.*?)(?:_スケジュール)?$/);
    const user = (matched && matched[1] ? matched[1] : base).trim();

    if (!user) {
        throw new Error(`ユーザー名をファイル名から抽出できません: ${fileName}`);
    }

    return user;
}

function normalizeNameForCompare(value) {
    return String(value || '').replace(/[\s\u3000]/g, '').toLowerCase();
}

function profileNames(profile) {
    const names = new Set();

    const add = (v) => {
        if (v) names.add(String(v));
    };

    add(profile.name);
    add(profile.nickName);
    add(profile.displayName);
    add(profile.email);
    add(profile.userName);

    if (profile.userName && typeof profile.userName === 'object') {
        const u = profile.userName;
        add(u.firstName && u.lastName ? `${u.lastName} ${u.firstName}` : '');
        add(u.givenName && u.familyName ? `${u.familyName} ${u.givenName}` : '');
        add(u.firstName && u.lastName ? `${u.lastName}${u.firstName}` : '');
        add(u.givenName && u.familyName ? `${u.familyName}${u.givenName}` : '');
        add(u.displayName);
        add(u.fullName);
    }

    if (profile.name && typeof profile.name === 'object') {
        const n = profile.name;
        add(n.displayName);
        add(n.fullName);
        add(n.familyName && n.givenName ? `${n.familyName} ${n.givenName}` : '');
        add(n.familyName && n.givenName ? `${n.familyName}${n.givenName}` : '');
    }

    return Array.from(names);
}

async function fetchAllLineworksUsers(accessToken, domainId) {
    const users = [];
    let cursor = '';

    while (true) {
        const params = new URLSearchParams();
        params.set('count', '100');
        if (domainId) {
            params.set('domainId', domainId);
        }
        if (cursor) {
            params.set('cursor', cursor);
        }

        const query = params.toString();
        const apiUrl = `${LW_API_BASE_URL}/users${query ? `?${query}` : ''}`;
        const response = await lwFetch(apiUrl, {
            method: 'GET',
            headers: {
                Authorization: `Bearer ${accessToken}`
            }
        });

        const text = await response.text();
        let data;
        try {
            data = JSON.parse(text);
        } catch (error) {
            throw new Error('LINE WORKSユーザー一覧の解析に失敗しました');
        }

        if (!response.ok) {
            throw new Error(`LINE WORKSユーザー一覧取得に失敗しました: ${response.status} ${JSON.stringify(data)}`);
        }

        const pageUsers = Array.isArray(data.users) ? data.users : [];
        users.push(...pageUsers);

        const nextCursor = data?.responseMetaData?.nextCursor || '';
        if (!nextCursor || nextCursor === cursor) {
            break;
        }
        cursor = nextCursor;
    }

    return users;
}

function findLineworksUserByName(users, sourceUserName) {
    const normalizedSource = normalizeNameForCompare(sourceUserName);
    for (const user of users) {
        const candidates = profileNames(user);
        const matched = candidates.some(name => normalizeNameForCompare(name) === normalizedSource);
        if (matched) {
            return user;
        }
    }

    return null;
}

function normalizeLoginIdForCompare(value) {
    return String(value || '').trim().toLowerCase();
}

function loginIdCandidates(profile) {
    const ids = new Set();

    const add = (v) => {
        if (v) ids.add(String(v));
    };

    add(profile.email);
    add(profile.loginId);
    add(profile.userId);
    if (typeof profile.userName === 'string') {
        add(profile.userName);
    }
    if (profile.account && typeof profile.account === 'object') {
        add(profile.account.loginId);
        add(profile.account.email);
    }

    return Array.from(ids);
}

function findLineworksUserByLoginId(users, sourceLoginId) {
    const normalizedSource = normalizeLoginIdForCompare(sourceLoginId);
    for (const user of users) {
        const candidates = loginIdCandidates(user);
        const matched = candidates.some(id => normalizeLoginIdForCompare(id) === normalizedSource);
        if (matched) {
            return user;
        }
    }

    return null;
}

function parseCsvDate(value) {
    const normalized = String(value || '').trim();
    const matched = normalized.match(/^(\d{4})[/-](\d{1,2})[/-](\d{1,2})$/);
    if (!matched) {
        throw new Error(`日付形式が不正です: ${value}`);
    }

    const [, y, m, d] = matched;
    return `${y}-${String(Number(m)).padStart(2, '0')}-${String(Number(d)).padStart(2, '0')}`;
}

function parseCsvTime(value) {
    const normalized = String(value || '').trim();
    if (!normalized) {
        return '';
    }

    const hm = normalized.match(/^(\d{1,2}):(\d{2})$/);
    if (hm) {
        const hour = Number(hm[1]);
        const minute = Number(hm[2]);
        if (hour > 23 || minute > 59) {
            throw new Error(`時刻形式が不正です: ${value}`);
        }
        return `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}:00`;
    }

    const hhmm = normalized.match(/^(\d{2})(\d{2})$/);
    if (hhmm) {
        const hour = Number(hhmm[1]);
        const minute = Number(hhmm[2]);
        if (hour > 23 || minute > 59) {
            throw new Error(`時刻形式が不正です: ${value}`);
        }
        return `${hhmm[1]}:${hhmm[2]}:00`;
    }

    throw new Error(`時刻形式が不正です: ${value}`);
}

function sanitizeTextField(value) {
    // LINE WORKS API向けに制御文字を整理し、改行はLFに統一する
    return String(value || '')
        .replace(/\r\n?/g, '\n')
        .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, '')
        .trim();
}

function encodeNewlineForApi(value) {
    return String(value || '').replace(/\n/g, '\\n');
}

function toLineworksDateTime(dateText, timeText) {
    // LINE WORKS仕様: dateTimeはYYYY-MM-DDTHH:mm:ss（オフセットなし）
    return `${dateText}T${timeText}`;
}

function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

async function waitApiInterval() {
    const now = Date.now();
    const elapsed = now - lastApiRequestAt;
    const waitMs = Math.max(0, LW_API_WAIT_MS - elapsed);
    if (waitMs > 0) {
        await sleep(waitMs);
    }
    lastApiRequestAt = Date.now();
}

async function lwFetch(url, options) {
    await waitApiInterval();
    return fetch(url, options);
}

function isRetryableCalendarError(status, responseText) {
    if (status >= 500 || status === 429) {
        return true;
    }

    try {
        const body = JSON.parse(responseText);
        return body && body.code === 'SERVICE_UNAVAILABLE';
    } catch (_) {
        return false;
    }
}

function eventStartForLog(eventComponent) {
    const start = eventComponent && eventComponent.start ? eventComponent.start : {};
    if (start.dateTime) {
        return String(start.dateTime).replace('T', ' ');
    }
    if (start.date) {
        return String(start.date);
    }
    return '(date-unknown)';
}

function eventLabelForLog(eventComponent) {
    return `${eventStartForLog(eventComponent)} ${eventComponent.summary}`;
}

function nextDate(dateText) {
    const d = new Date(`${dateText}T00:00:00`);
    if (Number.isNaN(d.getTime())) {
        throw new Error(`日付変換に失敗しました: ${dateText}`);
    }
    d.setDate(d.getDate() + 1);
    const yyyy = d.getFullYear();
    const MM = String(d.getMonth() + 1).padStart(2, '0');
    const dd = String(d.getDate()).padStart(2, '0');
    return `${yyyy}-${MM}-${dd}`;
}

function validateCsvHeaders(headers) {
    const missing = REQUIRED_CSV_HEADERS.filter(header => !headers.includes(header));
    if (missing.length > 0) {
        throw new Error(`必須ヘッダ不足: ${missing.join(', ')}`);
    }
}

function extractCsvHeaders(content) {
    const headerRows = parse(content, {
        to_line: 1,
        bom: true,
        relax_quotes: true
    });
    if (!Array.isArray(headerRows) || headerRows.length === 0) {
        return [];
    }
    return Array.isArray(headerRows[0]) ? headerRows[0].map(v => String(v || '').trim()) : [];
}

function buildEventComponentFromCsvRow(row) {
    const startDate = parseCsvDate(row['開始日']);
    const endDate = parseCsvDate(row['終了日']);
    const startTime = parseCsvTime(row['開始時刻']);
    const endTime = parseCsvTime(row['終了時刻']);

    const category = sanitizeTextField(row['分類']);
    const rawSummary = sanitizeTextField(row['予定']);
    const summaryBase = rawSummary === '－－－－'
        ? (category || '(件名なし)')
        : (rawSummary || '(件名なし)');
    const summary = encodeNewlineForApi(summaryBase);
    const registerTo = sanitizeTextField(row['登録先']);
    const note = sanitizeTextField(row['備考']);

    const descriptionParts = [];
    if (category) descriptionParts.push(`分類: ${category}`);
    if (registerTo) descriptionParts.push(`登録先: ${registerTo}`);
    if (note) descriptionParts.push(note);

    const component = {
        summary,
        description: descriptionParts.join('\n')
    };

    if (!startTime && !endTime) {
        component.start = { date: startDate };
        // 終日予定は終了日を排他的に扱うため1日加算
        component.end = { date: nextDate(endDate) };
        return component;
    }

    if (startTime === '00:00:00' && endTime === '00:00:00') {
        // 00:00-00:00 は開始日の終日予定として扱う
        component.start = { date: startDate };
        component.end = { date: nextDate(startDate) };
        return component;
    }

    if (!startTime || !endTime) {
        throw new Error('開始時刻と終了時刻は両方指定してください');
    }

    component.start = {
        dateTime: toLineworksDateTime(startDate, startTime),
        timeZone: DEFAULT_TIME_ZONE
    };
    component.end = {
        dateTime: toLineworksDateTime(endDate, endTime),
        timeZone: DEFAULT_TIME_ZONE
    };

    return component;
}

async function createCalendarEvent(accessToken, userId, eventComponent) {
    const endpoint = LW_EVENT_ENDPOINT_TEMPLATE.replace('{userId}', encodeURIComponent(userId));
    const url = `${LW_API_BASE_URL}${endpoint}`;
    const requestBody = {
        eventComponents: [eventComponent],
        sendNotification: LW_SEND_NOTIFICATION
    };

    if (LW_DRY_RUN) {
        console.log(`[DRY-RUN] ${userId} ${eventLabelForLog(eventComponent)}`);
        return;
    }

    if (LW_PRE_IMPORT_TEST) {
        console.log(`[PRE-IMPORT-TEST] POST skipped: ${userId} ${eventLabelForLog(eventComponent)} -> ${url}`);
        return;
    }

    let lastError = null;
    for (let attempt = 1; attempt <= LW_RETRY_MAX; attempt += 1) {
        const response = await lwFetch(url, {
            method: 'POST',
            headers: {
                Authorization: `Bearer ${accessToken}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(requestBody)
        });

        if (response.ok) {
            return;
        }

        const detail = await response.text();
        lastError = new Error(`登録失敗: ${response.status} ${detail}`);

        if (!isRetryableCalendarError(response.status, detail) || attempt === LW_RETRY_MAX) {
            break;
        }

        const waitMs = LW_RETRY_BASE_MS * (2 ** (attempt - 1));
        console.warn(`[RETRY] ${eventLabelForLog(eventComponent)} attempt=${attempt}/${LW_RETRY_MAX} wait=${waitMs}ms`);
        await sleep(waitMs);
    }

    throw lastError;
}

async function processCsvFile(fileName, accessToken, users) {
    const filePath = path.join(IMPORT_DIR, fileName);
    const content = fs.readFileSync(filePath, 'utf8');
    const sourceUserName = extractUserNameFromFilename(fileName);
    const mappedName = normalizeUserId(sourceUserName);
    let profile = findLineworksUserByName(users, mappedName);
    if (!profile) {
        profile = findLineworksUserByLoginId(users, mappedName);
        if (profile) {
            console.warn(`[MATCH-FALLBACK] ${fileName}: 名前照合NG -> ログインID照合OK (${mappedName})`);
        }
    }
    if (!profile) {
        throw new Error(`ユーザー照合失敗(名前/ログインID): file='${sourceUserName}', key='${mappedName}'`);
    }

    const userId = profile.userId || profile.id;
    if (!userId) {
        throw new Error(`ユーザーID未取得: file='${sourceUserName}'`);
    }

    const records = parse(content, {
        columns: true,
        skip_empty_lines: true,
        bom: true
    });
    validateCsvHeaders(extractCsvHeaders(content));

    if (records.length === 0) {
        console.log(`[SKIP] ${fileName}: データ行なし`);
        return { success: 0, failed: 1 };
    }

    let success = 0;
    let failed = 0;

    for (let i = 0; i < records.length; i += 1) {
        const row = records[i];
        try {
            const eventComponent = buildEventComponentFromCsvRow(row);
            await createCalendarEvent(accessToken, userId, eventComponent);
            success += 1;
            console.log(`[OK] ${fileName} -> ${userId} ${eventLabelForLog(eventComponent)}`);
        } catch (error) {
            failed += 1;
            console.error(`[NG] ${fileName} 行${i + 2}: ${error.message}`);
        }
    }

    return { success, failed };
}

function moveProcessedFile(fileName, destinationDir) {
    const sourcePath = path.join(IMPORT_DIR, fileName);
    if (!fs.existsSync(sourcePath)) {
        return;
    }

    if (!fs.existsSync(destinationDir)) {
        fs.mkdirSync(destinationDir, { recursive: true });
    }

    let targetPath = path.join(destinationDir, fileName);
    if (fs.existsSync(targetPath)) {
        const parsed = path.parse(fileName);
        const stamp = Date.now();
        targetPath = path.join(destinationDir, `${parsed.name}_${stamp}${parsed.ext}`);
    }

    fs.renameSync(sourcePath, targetPath);
    console.log(`[MOVE] ${fileName} -> ${targetPath}`);
}

async function main() {
    ensureRequiredEnv();

    if (LW_DRY_RUN) {
        console.log('mode: DRY_RUN (認証・登録をスキップ)');
    } else if (LW_PRE_IMPORT_TEST) {
        console.log('mode: PRE_IMPORT_TEST (登録直前まで実行、POSTのみスキップ)');
    }

    if (!fs.existsSync(IMPORT_DIR)) {
        console.log('importフォルダが見つかりません');
        return;
    }

    const files = fs.readdirSync(IMPORT_DIR)
        .filter(file => file.toLowerCase().endsWith('.csv'))
        .sort();

    if (files.length === 0) {
        console.log('importフォルダにcsvファイルが見つかりません');
        return;
    }

    const accessToken = await getAccessToken(LW_SCOPE);
    const userLookupToken = await getAccessToken(LW_USER_LOOKUP_SCOPE);
    const users = await fetchAllLineworksUsers(userLookupToken, LW_USER_LOOKUP_DOMAIN_ID);
    if (users.length === 0) {
        throw new Error('LINE WORKSユーザー一覧が0件です');
    }
    console.log(`ユーザー一覧取得: ${users.length}件`);

    let totalSuccess = 0;
    let totalFailed = 0;
    let successFiles = 0;
    let failedFiles = 0;

    for (const file of files) {
        console.log(`--- processing ${file} ---`);
        let result;
        try {
            result = await processCsvFile(file, accessToken, users);
        } catch (error) {
            console.error(`[NG] ${file}: ${error.message}`);
            result = { success: 0, failed: 1 };
        }
        totalSuccess += result.success;
        totalFailed += result.failed;

        if (result.failed === 0 && result.success > 0) {
            moveProcessedFile(file, SUCCESS_DIR);
            successFiles += 1;
        } else {
            moveProcessedFile(file, FAIL_DIR);
            failedFiles += 1;
        }
    }

    console.log(`ファイル移動結果: success=${successFiles}, fail=${failedFiles}`);
    console.log(`完了: success=${totalSuccess}, failed=${totalFailed}`);
}

main().catch(error => {
    console.error(error.message || error);
    process.exit(1);
});