// index.js
const _ = require('lodash');

/**
 * 配列から重複を除去して返す
 * @param {Array} array - 処理対象の配列
 * @returns {Array} - 重複が除去された配列
 */
function uniqueArray(array) {
  if (!Array.isArray(array)) {
    throw new Error('Input must be an array');
  }
  return _.uniq(array);
}

/**
 * オブジェクトの深いマージを行う
 * @param {Object} target - マージ先オブジェクト
 * @param {Object} source - マージ元オブジェクト
 * @returns {Object} - マージされたオブジェクト
 */
function deepMerge(target, source) {
  return _.merge(target, source);
}

/**
 * 配列を指定されたサイズに分割する
 * @param {Array} array - 分割対象の配列
 * @param {number} size - チャンクサイズ
 * @returns {Array} - 分割された配列の配列
 */
function chunkArray(array, size) {
  if (!Array.isArray(array)) {
    throw new Error('First argument must be an array');
  }
  if (typeof size !== 'number' || size <= 0) {
    throw new Error('Size must be a positive number');
  }
  return _.chunk(array, size);
}

module.exports = {
  uniqueArray,
  deepMerge,
  chunkArray
};

// webhook-server.js
const express = require('express');
const crypto = require('crypto');
const app = express();

// ミドルウェア設定
app.use(express.json());

// Webhook署名の検証
function verifySignature(req, res, next) {
  const signature = req.headers['x-hub-signature-256'];
  const payload = JSON.stringify(req.body);
  const secret = process.env.WEBHOOK_SECRET;
  
  if (!signature || !secret) {
    return res.status(401).send('Unauthorized');
  }
  
  const expectedSignature = 'sha256=' + 
    crypto.createHmac('sha256', secret)
          .update(payload)
          .digest('hex');
  
  if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))) {
    return res.status(401).send('Unauthorized');
  }
  
  next();
}

// Push イベントの処理
app.post('/webhook/push', verifySignature, async (req, res) => {
  const { repository, commits, pusher } = req.body;
  
  console.log(`Push to ${repository.full_name} by ${pusher.name}`);
  console.log(`${commits.length} commits pushed`);
  
  // 自動デプロイメントのトリガー
  if (repository.default_branch === req.body.ref.replace('refs/heads/', '')) {
    try {
      await triggerDeployment(repository.full_name);
      console.log('Deployment triggered successfully');
    } catch (error) {
      console.error('Deployment failed:', error);
    }
  }
  
  res.status(200).send('OK');
});

// Pull Request イベントの処理
app.post('/webhook/pr', verifySignature, async (req, res) => {
  const { action, pull_request, repository } = req.body;
  
  console.log(`PR ${action}: ${pull_request.title}`);
  
  switch (action) {
    case 'opened':
      await handlePROpened(pull_request, repository);
      break;
    case 'closed':
      if (pull_request.merged) {
        await handlePRMerged(pull_request, repository);
      }
      break;
    case 'synchronize':
      await handlePRUpdated(pull_request, repository);
      break;
  }
  
  res.status(200).send('OK');
});

// Issue イベントの処理
app.post('/webhook/issues', verifySignature, async (req, res) => {
  const { action, issue, repository } = req.body;
  
  if (action === 'opened') {
    // 新しいIssueに自動ラベル付け
    await autoLabelIssue(issue, repository);
    
    // 担当者の自動割当
    await autoAssignIssue(issue, repository);
    
    // Slack通知
    await sendSlackNotification({
      text: `New issue created: ${issue.title}`,
      url: issue.html_url,
      repository: repository.full_name
    });
  }
  
  res.status(200).send('OK');
});

// 自動デプロイメント機能
async function triggerDeployment(repoName) {
  const deployScript = './deploy.sh';
  const { exec } = require('child_process');
  
  return new Promise((resolve, reject) => {
    exec(`${deployScript} ${repoName}`, (error, stdout, stderr) => {
      if (error) {
        reject(error);
      } else {
        resolve(stdout);
      }
    });
  });
}

// Issue の自動ラベル付け
async function autoLabelIssue(issue, repository) {
  const { Octokit } = require('@octokit/rest');
  const octokit = new Octokit({
    auth: process.env.GITHUB_TOKEN
  });
  
  const labels = [];
  const title = issue.title.toLowerCase();
  const body = issue.body.toLowerCase();
  
  // タイトルと本文から自動でラベルを判定
  if (title.includes('bug') || body.includes('error')) {
    labels.push('bug');
  }
  if (title.includes('feature') || body.includes('enhancement')) {
    labels.push('enhancement');
  }
  if (title.includes('doc') || body.includes('documentation')) {
    labels.push('documentation');
  }
  
  if (labels.length > 0) {
    await octokit.rest.issues.addLabels({
      owner: repository.owner.login,
      repo: repository.name,
      issue_number: issue.number,
      labels: labels
    });
  }
}

// Slack通知
async function sendSlackNotification(data) {
  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
  if (!webhookUrl) return;
  
  const payload = {
    text: data.text,
    attachments: [{
      color: 'good',
      fields: [
        {
          title: 'Repository',
          value: data.repository,
          short: true
        },
        {
          title: 'Link',
          value: `<${data.url}|View on GitHub>`,
          short: true
        }
      ]
    }]
  };
  
  try {
    await fetch(webhookUrl, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload)
    });
  } catch (error) {
    console.error('Failed to send Slack notification:', error);
  }
}

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Webhook server running on port ${PORT}`);
});

// advanced-webhook-handlers.js

// マルチ環境デプロイメント
async function handleMultiStageDeployment(pullRequest, repository) {
  const environments = ['development', 'staging', 'production'];
  
  for (const env of environments) {
    if (env === 'production' && !pullRequest.merged) {
      continue; // 本番環境はマージ後のみ
    }
    
    try {
      const deploymentId = await createDeployment(repository, pullRequest, env);
      await executeDeployment(deploymentId, env);
      await updateDeploymentStatus(deploymentId, 'success');
    } catch (error) {
      await updateDeploymentStatus(deploymentId, 'failure');
      throw error;
    }
  }
}

// セキュリティスキャンの自動実行
async function handleSecurityScan(repository, commits) {
  const changedFiles = commits.flatMap(commit => 
    [...commit.added, ...commit.modified]
  );
  
  // 依存関係ファイルが変更された場合
  const dependencyFiles = ['package.json', 'requirements.txt', 'go.mod'];
  const hasDependencyChanges = changedFiles.some(file => 
    dependencyFiles.some(depFile => file.includes(depFile))
  );
  
  if (hasDependencyChanges) {
    await triggerSecurityScan(repository);
  }
}

// パフォーマンス テストの自動実行
async function handlePerformanceTest(pullRequest, repository) {
  const performanceLabels = ['performance', 'optimization'];
  const hasPerformanceLabel = pullRequest.labels.some(label => 
    performanceLabels.includes(label.name)
  );
  
  if (hasPerformanceLabel) {
    const testResults = await runPerformanceTests(repository, pullRequest.head.sha);
    await commentPerformanceResults(pullRequest, testResults);
  }
}

// 自動コードレビュー
async function handleAutomatedCodeReview(pullRequest, repository) {
  const { Octokit } = require('@octokit/rest');
  const octokit = new Octokit({ auth: process.env.GITHUB_TOKEN });
  
  // ファイル差分の取得
  const { data: files } = await octokit.rest.pulls.listFiles({
    owner: repository.owner.login,
    repo: repository.name,
    pull_number: pullRequest.number
  });
  
  const reviewComments = [];
  
  for (const file of files) {
    // 大きなファイルの警告
    if (file.changes > 500) {
      reviewComments.push({
        path: file.filename,
        line: 1,
        body: '⚠️ This file has over 500 changes. Consider breaking it into smaller PRs.'
      });
    }
    
    // セキュリティパターンのチェック
    if (file.patch && file.patch.includes('password')) {
      reviewComments.push({
        path: file.filename,
        line: findLineNumber(file.patch, 'password'),
        body: '🔒 Potential security issue: hardcoded password detected.'
      });
    }
  }
  
  if (reviewComments.length > 0) {
    await octokit.rest.pulls.createReview({
      owner: repository.owner.login,
      repo: repository.name,
      pull_number: pullRequest.number,
      event: 'REQUEST_CHANGES',
      body: 'Automated code review found some issues that need attention.',
      comments: reviewComments
    });
  }
}

// external-integrations.js

// Jira統合
async function syncWithJira(issue, action) {
  if (!process.env.JIRA_API_TOKEN) return;
  
  const jiraTicketMatch = issue.body.match(/JIRA-(\d+)/);
  if (!jiraTicketMatch) return;
  
  const jiraTicketId = jiraTicketMatch[1];
  const jiraApi = new JiraApi({
    protocol: 'https',
    host: process.env.JIRA_HOST,
    username: process.env.JIRA_USERNAME,
    password: process.env.JIRA_API_TOKEN,
    apiVersion: '2',
    strictSSL: true
  });
  
  try {
    await jiraApi.addComment(jiraTicketId, `GitHub Issue ${action}: ${issue.html_url}`);
    
    if (action === 'closed') {
      await jiraApi.transitionIssue(jiraTicketId, {
        transition: { id: '31' } // 'Done' 状態へ
      });
    }
  } catch (error) {
    console.error('Jira sync failed:', error);
  }
}

// データベース同期
async function syncToDatabase(event, data) {
  const db = require('./db');
  
  const record = {
    event_type: event,
    repository: data.repository.full_name,
    actor: data.sender.login,
    created_at: new Date(),
    payload: JSON.stringify(data)
  };
  
  await db.events.create(record);
  
  // 統計情報の更新
  await updateRepositoryStats(data.repository.full_name);
}

// メール通知システム
async function sendEmailNotification(event, data) {
  const sgMail = require('@sendgrid/mail');
  sgMail.setApiKey(process.env.SENDGRID_API_KEY);
  
  const msg = {
    to: getNotificationRecipients(data.repository.full_name),
    from: 'noreply@example.com',
    subject: `GitHub ${event}: ${data.repository.name}`,
    html: generateEmailTemplate(event, data)
  };
  
  try {
    await sgMail.send(msg);
  } catch (error) {
    console.error('Email notification failed:', error);
  }
}