import assert from 'node:assert/strict';
import fs from 'node:fs';
import test from 'node:test';
import { createMindSpaceImageGenerationService } from './mindspace-image-generation.mjs';

function passingReviewService(overrides = {}) {
  return {
    async review() {
      return {
        ok: true,
        pass: true,
        verdict: 'pass',
        relevanceScore: 92,
        minimumScore: 70,
        ...overrides,
      };
    },
  };
}

test('MindSpace asset schema accepts image_make as a source type', () => {
  const schemaSql = fs.readFileSync(new URL('./schema.sql', import.meta.url), 'utf8');
  const dbSource = fs.readFileSync(new URL('./db.mjs', import.meta.url), 'utf8');
  assert.match(schemaSql, /source_type ENUM\([^\n]*'image_make'/);
  assert.match(dbSource, /MODIFY source_type ENUM\([^\n]*'image_make'/);
});

test('MindSpace image generation stays inert while the admin purpose is disabled', async () => {
  const service = createMindSpaceImageGenerationService({
    configService: {
      async resolveImageGenerationPurpose() {
        return { ok: false, code: 'purpose_disabled', message: 'disabled' };
      },
    },
  });
  assert.deepEqual(await service.generate({ userId: 'user-1', purpose: 'hero', prompt: 'x' }), {
    ok: false,
    code: 'purpose_disabled',
    message: 'disabled',
    fallback: true,
  });
});

test('MindSpace image generation stores the result before acknowledging temporary output', async () => {
  const order = [];
  const service = createMindSpaceImageGenerationService({
    configService: {
      async resolveImageGenerationPurpose() {
        return { ok: true, presetId: 'memind_dark_hero' };
      },
    },
    imageMakeClient: {
      async generateImage(input) {
        order.push(['generate', input.presetId]);
        return {
          jobId: 'job-1', buffer: Buffer.from('image'), mimeType: 'image/webp',
          sha256: 'abc', width: 512, height: 512,
        };
      },
      async acknowledge(jobId, assetId) { order.push(['ack', jobId, assetId]); },
    },
    imageReviewService: {
      async review() {
        order.push(['review']);
        return passingReviewService().review();
      },
    },
    assetService: {
      async createChatAsset(userId, input) {
        order.push(['store', userId, input.sourceType, input.categoryCode]);
        return {
          id: 'asset-1',
          publicUrl: 'https://example.test/image.webp',
          workspaceRelativePath: 'public/images/2026-07-20/hero.webp',
        };
      },
    },
  });
  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: 'x' });
  assert.equal(result.ok, true);
  assert.equal(result.asset.id, 'asset-1');
  assert.equal(result.asset.workspaceRelativePath, 'public/images/2026-07-20/hero.webp');
  assert.equal(result.asset.htmlSrc, 'images/2026-07-20/hero.webp');
  assert.deepEqual(order, [
    ['generate', 'memind_dark_hero'],
    ['review'],
    ['store', 'user-1', 'image_make', 'public'],
    ['ack', 'job-1', 'asset-1'],
  ]);
});

test('MindSpace image generation converts provider failures into an explicit fallback result', async () => {
  const service = createMindSpaceImageGenerationService({
    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'x' }; } },
    assetService: { async createChatAsset() { throw new Error('must not run'); } },
    imageMakeClient: { async generateImage() { throw Object.assign(new Error('offline'), { code: 'IMAGE_MAKE_HTTP_ERROR' }); } },
    logger: { warn() {} },
  });
  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: 'x' });
  assert.deepEqual(result, {
    ok: false,
    fallback: true,
    code: 'IMAGE_MAKE_HTTP_ERROR',
    message: '图片生成暂不可用，已保留原有流程',
  });
});

test('MindSpace image generation does not return success without an HTML-ready source path', async () => {
  const service = createMindSpaceImageGenerationService({
    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'x' }; } },
    assetService: { async createChatAsset() { return { id: 'asset-1' }; } },
    imageMakeClient: {
      async generateImage() {
        return {
          jobId: 'job-1', buffer: Buffer.from('image'), mimeType: 'image/webp',
          sha256: 'abc', width: 512, height: 512,
        };
      },
      async acknowledge() {},
    },
    imageReviewService: passingReviewService(),
    logger: { warn() {} },
  });

  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: 'x' });
  assert.deepEqual(result, {
    ok: false,
    fallback: true,
    code: 'IMAGE_ASSET_PATH_UNAVAILABLE',
    message: '图片生成暂不可用，已保留原有流程',
  });
});

test('MindSpace image generation applies an optional per-purpose size override', async () => {
  let request = null;
  const service = createMindSpaceImageGenerationService({
    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'memind_dark_hero' }; } },
    assetService: {
      async createChatAsset() {
        return { id: 'asset-1', workspaceRelativePath: 'public/images/2026-07-20/hero.webp' };
      },
    },
    imageMakeClient: {
      async generateImage(input) {
        request = input;
        return {
          jobId: 'job-1', buffer: Buffer.from('image'), mimeType: 'image/webp',
          sha256: 'abc', width: input.width, height: input.height,
        };
      },
      async acknowledge() {},
    },
    imageReviewService: passingReviewService(),
    env: { IMAGE_MAKE_HERO_WIDTH: '768', IMAGE_MAKE_HERO_HEIGHT: '432' },
  });

  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: 'x' });
  assert.equal(result.ok, true);
  assert.equal(request.width, 768);
  assert.equal(request.height, 432);
});

test('MindSpace image generation retries a semantic mismatch and stores only a reviewed result', async () => {
  const generatedRequests = [];
  let reviewCount = 0;
  let storeCount = 0;
  const service = createMindSpaceImageGenerationService({
    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'hero' }; } },
    assetService: {
      async createChatAsset() {
        storeCount += 1;
        return { id: 'asset-pass', workspaceRelativePath: 'public/images/hero-pass.webp' };
      },
    },
    imageMakeClient: {
      async generateImage(input) {
        generatedRequests.push(input);
        return {
          jobId: `job-${generatedRequests.length}`,
          buffer: Buffer.from(`image-${generatedRequests.length}`),
          mimeType: 'image/webp', sha256: 'abc', width: 768, height: 432,
        };
      },
      async acknowledge() {},
    },
    imageReviewService: {
      async review() {
        reviewCount += 1;
        if (reviewCount === 1) {
          return {
            ok: true, pass: false, verdict: 'reject', relevanceScore: 0, minimumScore: 70,
            observedSubjects: ['人物', '沙发'],
            missingRequiredElements: ['竹海'],
            reason: '主体不符',
          };
        }
        return passingReviewService().review();
      },
    },
    env: { IMAGE_MAKE_SEMANTIC_REVIEW_MAX_ATTEMPTS: '3' },
    logger: { warn() {} },
  });

  const result = await service.generate({
    userId: 'user-1', purpose: 'hero', prompt: '安吉竹海', idempotencyKey: 'imgreq-review',
  });
  assert.equal(result.ok, true);
  assert.equal(result.jobId, 'job-2');
  assert.equal(storeCount, 1);
  assert.equal(generatedRequests.length, 2);
  assert.equal(generatedRequests[0].idempotencyKey, 'imgreq-review');
  assert.equal(generatedRequests[1].idempotencyKey, 'imgreq-review-review-2');
  assert.match(generatedRequests[1].prompt, /必须修正上次错误/);
  assert.match(generatedRequests[1].prompt, /缺失元素：竹海/);
});

test('MindSpace image generation blocks storage after all semantic review attempts fail', async () => {
  let generateCount = 0;
  let storeCount = 0;
  const service = createMindSpaceImageGenerationService({
    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'hero' }; } },
    assetService: { async createChatAsset() { storeCount += 1; } },
    imageMakeClient: {
      async generateImage() {
        generateCount += 1;
        return {
          jobId: `job-${generateCount}`, buffer: Buffer.from('bad'), mimeType: 'image/webp',
          sha256: 'abc', width: 768, height: 432,
        };
      },
    },
    imageReviewService: {
      async review() {
        return {
          ok: true, pass: false, verdict: 'reject', relevanceScore: 5, minimumScore: 70,
          observedSubjects: ['人物'], missingRequiredElements: ['竹海'], reason: '图文不符',
        };
      },
    },
    env: { IMAGE_MAKE_SEMANTIC_REVIEW_MAX_ATTEMPTS: '2' },
    logger: { warn() {} },
  });

  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: '安吉竹海' });
  assert.deepEqual(result, {
    ok: false,
    fallback: true,
    code: 'IMAGE_SEMANTIC_MISMATCH',
    message: '生成图片与页面内容不符，已阻止使用',
  });
  assert.equal(generateCount, 2);
  assert.equal(storeCount, 0);
});

test('MindSpace image generation fails closed when semantic review is unavailable', async () => {
  let storeCount = 0;
  const service = createMindSpaceImageGenerationService({
    configService: { async resolveImageGenerationPurpose() { return { ok: true, presetId: 'hero' }; } },
    assetService: { async createChatAsset() { storeCount += 1; } },
    imageMakeClient: {
      async generateImage() {
        return {
          jobId: 'job-1', buffer: Buffer.from('image'), mimeType: 'image/webp',
          sha256: 'abc', width: 768, height: 432,
        };
      },
    },
    imageReviewService: { async review() { return { ok: false, code: 'IMAGE_REVIEW_UNAVAILABLE' }; } },
    logger: { warn() {} },
  });

  const result = await service.generate({ userId: 'user-1', purpose: 'hero', prompt: '安吉竹海' });
  assert.equal(result.ok, false);
  assert.equal(result.code, 'IMAGE_REVIEW_UNAVAILABLE');
  assert.equal(storeCount, 0);
});