구글시트 야드 트레일러 현황 만들기 — 대시보드 3편 (수정·완성 버전)

// 야드 현황용 설정 상수 모음입니다.
const DASH_YARD_CONFIG = {
  TZ: 'America/New_York',              // 시간대는 고정
  MOVE_SHEET_NAME: 'TRAILER_MOVES',    // 이동 기록 시트 이름
  YARD_SHEET_NAME: 'YARD',             // 야드 슬롯 시트 이름
  VIEW_SHEET_NAME: 'TODAY',            // 대시보드 표시 시트
  VIEW_START_ROW: 30,                  // 야드 표 시작 행 (필요에 따라 조정)
  VIEW_START_COL: 1,                   // 야드 표 시작 열 (A열)
  MAX_SLOT_HOURS_OK: 2,                // 2시간 이내: 정상
  MAX_SLOT_HOURS_WARN: 4,              // 2~4시간: 주의
  COLOR_EMPTY: '#ffffff',              // 빈 슬롯 색
  COLOR_OK: '#e2f0d9',                 // 정상 점유 색(연녹색)
  COLOR_WARN: '#fff2cc',               // 경고 색(노랑 계열)
  COLOR_ALERT: '#f4cccc'               // 심각 색(빨강 계열)
};

/**
 * 야드 슬롯별 현재 점유 현황을 TODAY 시트에 그립니다.
 * LockService 로 동시 실행을 막아 TODAY 시트가 엉키지 않도록 합니다.
 */
function DASH_updateYardStatusView() {
  const lock = LockService.getDocumentLock();
  // 동시에 여러 실행이 TODAY 를 건드리지 않도록 최대 10초까지 대기
  const gotLock = lock.tryLock(10 * 1000);
  if (!gotLock) {
    throw new Error('야드 현황 갱신 잠금을 얻지 못했습니다. 잠시 후 다시 실행해 주세요.');
  }

  try {
    const ss = SpreadsheetApp.getActive();
    const moveSheet = ss.getSheetByName(DASH_YARD_CONFIG.MOVE_SHEET_NAME);
    const yardSheet = ss.getSheetByName(DASH_YARD_CONFIG.YARD_SHEET_NAME);
    const viewSheet = ss.getSheetByName(DASH_YARD_CONFIG.VIEW_SHEET_NAME);

    if (!moveSheet || !yardSheet || !viewSheet) {
      throw new Error('YARD, TRAILER_MOVES, TODAY 시트를 먼저 만들어 주세요.');
    }

    const now = new Date();
    const yardSlots = DASH_loadActiveYardSlots_(yardSheet);     // 활성 슬롯 목록
    const latestMoves = DASH_loadLatestMovesBySlot_(moveSheet); // 슬롯별 최신 상태
    const viewData = DASH_buildYardViewTable_(yardSlots, latestMoves, now);

    DASH_writeYardView_(viewSheet, viewData);   // TODAY에 값 쓰기
    DASH_colorYardView_(viewSheet, viewData);   // TODAY에 색 적용
  } finally {
    // 예외 발생 여부와 관계없이 잠금을 반드시 해제
    lock.releaseLock();
  }
}

/**
 * 테스트용 래퍼입니다. 실행하면 처리 완료 로그를 남기고,
 * 출력 데이터의 타입과 구조를 간단히 검증합니다.
 */
function DASH_testUpdateYardStatusView() {
  const ss = SpreadsheetApp.getActive();
  const viewSheet = ss.getSheetByName(DASH_YARD_CONFIG.VIEW_SHEET_NAME);
  if (!viewSheet) {
    throw new Error('TODAY 시트가 필요합니다.');
  }
  DASH_updateYardStatusView();

  const startRow = DASH_YARD_CONFIG.VIEW_START_ROW;
  const startCol = DASH_YARD_CONFIG.VIEW_START_COL;
  const lastRow = viewSheet.getLastRow();
  const rows = Math.max(0, lastRow - startRow + 1);
  if (rows <= 0) {
    Logger.log('야드 현황 데이터가 없습니다.');
    return;
  }

  const range = viewSheet.getRange(startRow, startCol, rows, 6);
  const values = range.getValues();

  // 기본적인 기대값 검증
  if (!Array.isArray(values)) {
    throw new Error('TODAY 야드 뷰 데이터가 배열이 아닙니다.');
  }
  if (values.length > 0) {
    const row = values[0];
    if (!Array.isArray(row) || row.length !== 6) {
      throw new Error('TODAY 야드 뷰 한 행은 길이 6의 배열이어야 합니다.');
    }
    if (typeof row[0] !== 'string' && typeof row[0] !== 'number') {
      throw new Error('첫 번째 열(슬롯ID)은 문자열 또는 숫자여야 합니다.');
    }
  }

  Logger.log('DASH_updateYardStatusView 실행 및 기본 구조 검증 완료');
}

/**
 * YARD 시트에서 활성 슬롯 목록을 읽어옵니다.
 * 반환: [{slotId, name}, ...]
 *
 * 열 가정: A열=슬롯ID, B열=이름, C열=활성 여부
 */
function DASH_loadActiveYardSlots_(yardSheet) {
  const lastRow = yardSheet.getLastRow();
  if (lastRow < 2) {
    // 헤더만 있는 경우
    return [];
  }

  const range = yardSheet.getRange(2, 1, lastRow - 1, 3); // A:C
  const values = range.getValues();

  const slots = [];
  const ACTIVE_VALUES = ['Y', 'YES', 'TRUE', '1'];

  for (let i = 0; i < values.length; i++) {
    const row = values[i];
    const slotId = row[0]; // A열
    const name = row[1];   // B열
    const active = row[2]; // C열

    if (!slotId) {
      // 슬롯ID 없으면 스킵 (지워진 행 등)
      continue;
    }

    const activeStr = String(active).trim().toUpperCase();
    if (!ACTIVE_VALUES.includes(activeStr)) {
      // 비활성 슬롯은 대시보드에서 제외
      continue;
    }

    slots.push({ slotId, name });
  }

  return slots;
}

/**
 * 활성 슬롯 테스트용.
 * 구조와 타입을 검증하고, 슬롯 목록을 로그에 찍습니다.
 */
function DASH_testLoadActiveYardSlots_() {
  const ss = SpreadsheetApp.getActive();
  const yardSheet = ss.getSheetByName(DASH_YARD_CONFIG.YARD_SHEET_NAME);
  if (!yardSheet) {
    throw new Error('YARD 시트가 필요합니다.');
  }
  const slots = DASH_loadActiveYardSlots_(yardSheet);

  // 기대값 검증: 배열/길이/필드 존재 여부/타입
  if (!Array.isArray(slots)) {
    throw new Error('DASH_loadActiveYardSlots_ 결과가 배열이 아닙니다.');
  }
  if (slots.length > 0) {
    const s = slots[0];
    if (typeof s !== 'object' || s === null) {
      throw new Error('슬롯 항목은 객체여야 합니다.');
    }
    if (!('slotId' in s) || !('name' in s)) {
      throw new Error('슬롯 객체에 slotId 또는 name 필드가 없습니다.');
    }
    if (typeof s.slotId !== 'string' && typeof s.slotId !== 'number') {
      throw new Error('slotId는 문자열 또는 숫자여야 합니다.');
    }
    if (typeof s.name !== 'string' && s.name !== null && s.name !== undefined) {
      throw new Error('name은 문자열이거나 빈 값이어야 합니다.');
    }
  }

  Logger.log('활성 슬롯: ' + JSON.stringify(slots));
}

/**
 * TRAILER_MOVES 시트에서 슬롯별 최신 이동 이력을 계산합니다.
 * 반환: {slotId: {slotId, container, status, movedAt}, ...}
 *
 * 열 가정: A열=기록시각, B열=슬롯ID, C열=컨테이너번호, D열=동작타입(IN/OUT/MOVE 등)
 */
function DASH_loadLatestMovesBySlot_(moveSheet) {
  const lastRow = moveSheet.getLastRow();
  if (lastRow < 2) {
    // 데이터 없음
    return {};
  }

  const range = moveSheet.getRange(2, 1, lastRow - 1, 4); // A:D
  const values = range.getValues();

  const latestBySlot = {};
  const ALLOWED_ACTIONS = ['IN', 'OUT', 'MOVE'];

  for (let i = 0; i < values.length; i++) {
    const row = values[i];
    const ts = row[0];         // 기록 시각
    const slotId = row[1];     // 슬롯 ID
    const container = row[2];  // 컨테이너 번호
    const actionRaw = row[3];  // IN/OUT/MOVE

    if (!slotId || !ts) {
      // 필수값 없으면 건너뜀
      continue;
    }
    if (!(ts instanceof Date)) {
      // 날짜형이 아니면 무시 (텍스트 등)
      continue;
    }

    const action = String(actionRaw || '').toUpperCase();
    if (!ALLOWED_ACTIONS.includes(action)) {
      // 허용되지 않은 동작코드는 대시보드에 반영하지 않음
      continue;
    }

    const prev = latestBySlot[slotId];
    if (!prev || prev.movedAt < ts) {
      // 이 슬롯에서 더 최신 기록이면 교체
      latestBySlot[slotId] = {
        slotId: slotId,
        container: container || '',
        status: action,
        movedAt: ts
      };
    }
  }

  return latestBySlot;
}

/**
 * 슬롯별 최신 이동 상태 테스트용.
 * 구조와 타입을 검증하고, 결과를 로그로 출력합니다.
 */
function DASH_testLoadLatestMovesBySlot_() {
  const ss = SpreadsheetApp.getActive();
  const moveSheet = ss.getSheetByName(DASH_YARD_CONFIG.MOVE_SHEET_NAME);
  if (!moveSheet) {
    throw new Error('TRAILER_MOVES 시트가 필요합니다.');
  }

  const latest = DASH_loadLatestMovesBySlot_(moveSheet);

  // 기대값 검증: 객체 여부/슬롯별 필드·타입 확인
  if (typeof latest !== 'object' || latest === null || Array.isArray(latest)) {
    throw new Error('DASH_loadLatestMovesBySlot_ 결과는 슬롯ID를 키로 하는 객체여야 합니다.');
  }

  const keys = Object.keys(latest);
  if (keys.length > 0) {
    const example = latest[keys[0]];
    if (typeof example !== 'object' || example === null) {
      throw new Error('슬롯 상태는 객체여야 합니다.');
    }
    const required = ['slotId', 'container', 'status', 'movedAt'];
    required.forEach(function (k) {
      if (!(k in example)) {
        throw new Error('슬롯 상태 객체에 ' + k + ' 필드가 없습니다.');
      }
    });
    if (!(example.movedAt instanceof Date)) {
      throw new Error('movedAt 필드는 Date 타입이어야 합니다.');
    }
    if (typeof example.status !== 'string') {
      throw new Error('status 필드는 문자열이어야 합니다.');
    }
  }

  Logger.log('슬롯별 최신 이동 상태: ' + JSON.stringify(latest));
}

/**
 * 야드 슬롯 현황 표를 만들기 위한 2차원 배열을 구성합니다.
 * 각 행: [슬롯ID, 이름, 컨테이너, 점유시각(Date 또는 ''), 경과시간(시간), 상태]
 */
function DASH_buildYardViewTable_(yardSlots, latestMoves, now) {
  const rows = [];
  const msPerHour = 1000 * 60 * 60;

  for (let i = 0; i < yardSlots.length; i++) {
    const slot = yardSlots[i];
    const slotId = slot.slotId;
    const name = slot.name || '';
    const move = latestMoves[slotId];

    let container = '';
    let startTime = '';
    let hours = '';
    let status = '';

    if (move && move.status === 'IN') {
      // 현재 점유 중
      container = move.container || '';
      startTime = move.movedAt;

      if (startTime instanceof Date && !isNaN(startTime.getTime())) {
        const diffMs = now.getTime() - startTime.getTime();
        const diffHours = diffMs / msPerHour;
        const safeHours = diffHours < 0 ? 0 : diffHours; // 미래 시각 방어
        const rounded = Math.round(safeHours * 10) / 10; // 소수 1자리 반올림
        hours = Number.isFinite(rounded) ? rounded : '';
      }

      status = 'IN';
    } else if (move) {
      // 마지막 동작이 OUT, MOVE 등인 경우
      status = move.status;
      // OUT 상태에서는 경과시간을 계산하지 않고 비워둡니다.
    }

    rows.push([slotId, name, container, startTime, hours, status]);
  }

  return rows;
}

/**
 * 현황 표 생성 테스트용.
 * 결과 배열을 로그로 확인하고, 타입과 구조를 검증합니다.
 */
function DASH_testBuildYardViewTable_() {
  const ss = SpreadsheetApp.getActive();
  const yardSheet = ss.getSheetByName(DASH_YARD_CONFIG.YARD_SHEET_NAME);
  const moveSheet = ss.getSheetByName(DASH_YARD_CONFIG.MOVE_SHEET_NAME);
  if (!yardSheet || !moveSheet) {
    throw new Error('YARD, TRAILER_MOVES 시트를 확인해 주세요.');
  }

  const slots = DASH_loadActiveYardSlots_(yardSheet);
  const latest = DASH_loadLatestMovesBySlot_(moveSheet);
  const now = new Date();
  const table = DASH_buildYardViewTable_(slots, latest, now);

  // 기대값 검증: 2차원 배열, 각 행 길이와 필드 타입 확인
  if (!Array.isArray(table)) {
    throw new Error('DASH_buildYardViewTable_ 결과가 배열이 아닙니다.');
  }
  if (table.length > 0) {
    const row = table[0];
    if (!Array.isArray(row)) {
      throw new Error('야드 뷰 한 행은 배열이어야 합니다.');
    }
    if (row.length !== 6) {
      throw new Error('야드 뷰 한 행은 6개의 필드를 가져야 합니다.');
    }

    const [slotId, name, container, startTime, hours, status] = row;

    if (typeof slotId !== 'string' && typeof slotId !== 'number') {
      throw new Error('슬롯ID는 문자열 또는 숫자여야 합니다.');
    }
    if (typeof name !== 'string' && name !== null && name !== undefined) {
      throw new Error('슬롯 이름은 문자열이거나 빈 값이어야 합니다.');
    }
    if (typeof container !== 'string' && container !== '') {
      throw new Error('컨테이너 번호는 문자열이거나 빈 문자열이어야 합니다.');
    }
    if (!(startTime === '' || startTime instanceof Date)) {
      throw new Error('점유시각은 Date 또는 빈 문자열이어야 합니다.');
    }
    if (!(hours === '' || typeof hours === 'number')) {
      throw new Error('경과시간은 숫자 또는 빈 문자열이어야 합니다.');
    }
    if (typeof status !== 'string') {
      throw new Error('상태코드는 문자열이어야 합니다.');
    }
  }

  Logger.log('야드 뷰 테이블: ' + JSON.stringify(table));
}

/**
 * TODAY 시트의 야드 구역에 현황 표를 씁니다.
 */
function DASH_writeYardView_(viewSheet, viewData) {
  const startRow = DASH_YARD_CONFIG.VIEW_START_ROW;
  const startCol = DASH_YARD_CONFIG.VIEW_START_COL;

  const maxRows = Math.max(viewData.length, 1);
  const clearRange = viewSheet.getRange(startRow, startCol, maxRows, 6);
  // 이전 데이터 및 서식 제거
  clearRange.clearContent();
  clearRange.clearFormat();

  if (viewData.length === 0) {
    // 보여 줄 데이터가 없으면 여기까지
    return;
  }

  const range = viewSheet.getRange(startRow, startCol, viewData.length, 6);
  range.setValues(viewData);

  // 점유 시각 열(4번째 열)에 시각 형식을 지정합니다.
  const timeRange = viewSheet.getRange(startRow, startCol + 3, viewData.length, 1);
  timeRange.setNumberFormat('MM-dd HH:mm');
}

/**
 * 쓰기 동작 테스트용.
 * viewData 구조를 검증하고 TODAY에 실제로 써 봅니다.
 */
function DASH_testWriteYardView_() {
  const ss = SpreadsheetApp.getActive();
  const yardSheet = ss.getSheetByName(DASH_YARD_CONFIG.YARD_SHEET_NAME);
  const moveSheet = ss.getSheetByName(DASH_YARD_CONFIG.MOVE_SHEET_NAME);
  const viewSheet = ss.getSheetByName(DASH_YARD_CONFIG.VIEW_SHEET_NAME);
  if (!yardSheet || !moveSheet || !viewSheet) {
    throw new Error('YARD, TRAILER_MOVES, TODAY 시트를 확인해 주세요.');
  }

  const slots = DASH_loadActiveYardSlots_(yardSheet);
  const latest = DASH_loadLatestMovesBySlot_(moveSheet);
  const now = new Date();
  const table = DASH_buildYardViewTable_(slots, latest, now);

  // viewData 기본 검증
  if (!Array.isArray(table)) {
    throw new Error('viewData(table)가 배열이 아닙니다.');
  }
  if (table.length > 0) {
    const row = table[0];
    if (!Array.isArray(row) || row.length !== 6) {
      throw new Error('viewData 한 행은 길이 6의 배열이어야 합니다.');
    }
  }

  DASH_writeYardView_(viewSheet, table);

  // TODAY에 실제로 쓴 후, 다시 읽어서 길이와 타입 확인
  const startRow = DASH_YARD_CONFIG.VIEW_START_ROW;
  const startCol = DASH_YARD_CONFIG.VIEW_START_COL;
  const range = viewSheet.getRange(startRow, startCol, table.length || 1, 6);
  const written = range.getValues();
  if (!Array.isArray(written)) {
    throw new Error('TODAY에서 읽은 데이터가 배열이 아닙니다.');
  }

  Logger.log('TODAY 야드 뷰 쓰기 및 기본 검증 완료, 행 수: ' + written.length);
}

/**
 * TODAY 시트의 야드 현황 구역에 경과 시간 기준 색을 입힙니다.
 */
function DASH_colorYardView_(viewSheet, viewData) {
  const startRow = DASH_YARD_CONFIG.VIEW_START_ROW;
  const startCol = DASH_YARD_CONFIG.VIEW_START_COL;
  const rows = viewData.length;
  if (rows === 0) {
    return;
  }

  const colors = [];
  for (let i = 0; i < rows; i++) {
    const row = viewData[i];
    const container = row[2]; // 컨테이너
    const hours = row[4];     // 경과 시간
    let color = DASH_YARD_CONFIG.COLOR_EMPTY;

    if (container && Number.isFinite(hours)) {
      if (hours <= DASH_YARD_CONFIG.MAX_SLOT_HOURS_OK) {
        color = DASH_YARD_CONFIG.COLOR_OK;
      } else if (hours <= DASH_YARD_CONFIG.MAX_SLOT_HOURS_WARN) {
        color = DASH_YARD_CONFIG.COLOR_WARN;
      } else {
        color = DASH_YARD_CONFIG.COLOR_ALERT;
      }
    }

    const rowColors = [];
    for (let c = 0; c < 6; c++) {
      rowColors.push(color);
    }
    colors.push(rowColors);
  }

  const range = viewSheet.getRange(startRow, startCol, rows, 6);
  range.setBackgrounds(colors);
}

/**
 * 색상 적용 테스트 함수입니다.
 * 인메모리 viewData 구조를 검증하고,
 * TODAY에 이미 쓰여 있는 데이터를 다시 읽어서 색만 입혀 봅니다.
 */
function DASH_testColorYardView_() {
  const ss = SpreadsheetApp.getActive();
  const viewSheet = ss.getSheetByName(DASH_YARD_CONFIG.VIEW_SHEET_NAME);
  if (!viewSheet) {
    throw new Error('TODAY 시트가 필요합니다.');
  }

  const startRow = DASH_YARD_CONFIG.VIEW_START_ROW;
  const startCol = DASH_YARD_CONFIG.VIEW_START_COL;
  const lastRow = viewSheet.getLastRow();
  const rows = Math.max(0, lastRow - startRow + 1);
  if (rows <= 0) {
    Logger.log('TODAY 야드 구역에 데이터가 없습니다.');
    return;
  }

  const range = viewSheet.getRange(startRow, startCol, rows, 6);
  const values = range.getValues();

  // 기대값 검증: 2차원 배열, 각 행 길이 및 hours 타입
  if (!Array.isArray(values)) {
    throw new Error('TODAY 야드 뷰 값이 배열이 아닙니다.');
  }
  if (values.length > 0) {
    const row = values[0];
    if (!Array.isArray(row) || row.length !== 6) {
      throw new Error('TODAY 야드 뷰 한 행은 길이 6의 배열이어야 합니다.');
    }
    const hours = row[4];
    if (!(hours === '' || typeof hours === 'number')) {
      throw new Error('경과시간 열은 숫자 또는 빈 문자열이어야 합니다.');
    }
  }

  DASH_colorYardView_(viewSheet, values);
  Logger.log('야드 뷰 색상 적용 완료');
}