船舶関連ソフトウェア¶

// AISメッセージのデコード・処理システム
interface AISMessage {
  messageType: number;
  mmsi: number;
  timestamp: Date;
  repeatIndicator?: number;
}

interface PositionReport extends AISMessage {
  messageType: 1 | 2 | 3;
  navigationStatus: NavigationStatus;
  rateOfTurn?: number;
  speedOverGround: number;
  positionAccuracy: boolean;
  longitude: number;
  latitude: number;
  courseOverGround: number;
  trueHeading?: number;
  timeStamp: number;
  specialManoeuvre?: number;
  raim: boolean;
}

interface StaticData extends AISMessage {
  messageType: 5;
  aisVersion: number;
  imoNumber: number;
  callSign: string;
  vesselName: string;
  shipType: number;
  dimensions: {
    toBow: number;
    toStern: number;
    toPort: number;
    toStarboard: number;
  };
  typeOfEPFD: number;
  eta: {
    month: number;
    day: number;
    hour: number;
    minute: number;
  };
  maximumStaticDraught: number;
  destination: string;
  dte: boolean;
}

enum NavigationStatus {
  UnderWayUsingEngine = 0,
  AtAnchor = 1,
  NotUnderCommand = 2,
  RestrictedManeuverability = 3,
  ConstrainedByDraught = 4,
  Moored = 5,
  Aground = 6,
  EngagedInFishing = 7,
  UnderWaySailing = 8,
  NotDefined = 15
}

class AISProcessor {
  private vessels = new Map<number, VesselInfo>();
  private messageHandlers = new Map<number, Function>();

  constructor() {
    this.setupMessageHandlers();
  }

  private setupMessageHandlers(): void {
    this.messageHandlers.set(1, this.handlePositionReport.bind(this));
    this.messageHandlers.set(2, this.handlePositionReport.bind(this));
    this.messageHandlers.set(3, this.handlePositionReport.bind(this));
    this.messageHandlers.set(5, this.handleStaticData.bind(this));
  }

  // AISメッセージの処理
  processMessage(rawMessage: string): void {
    try {
      const decoded = this.decodeAISMessage(rawMessage);
      const handler = this.messageHandlers.get(decoded.messageType);

      if (handler) {
        handler(decoded);
      }

      this.updateVesselInfo(decoded);
    } catch (error) {
      console.error('AIS message processing error:', error);
    }
  }

  private handlePositionReport(message: PositionReport): void {
    const vessel = this.vessels.get(message.mmsi) || this.createNewVessel(message.mmsi);

    // 位置履歴の管理
    vessel.positionHistory.push({
      position: { latitude: message.latitude, longitude: message.longitude },
      timestamp: message.timestamp,
      sog: message.speedOverGround,
      cog: message.courseOverGround
    });

    // 最新100件のみ保持
    if (vessel.positionHistory.length > 100) {
      vessel.positionHistory.shift();
    }

    // 衝突リスクの評価
    this.assessCollisionRisk(vessel);

    // 異常行動の検知
    this.detectAbnormalBehavior(vessel, message);
  }

  private handleStaticData(message: StaticData): void {
    const vessel = this.vessels.get(message.mmsi) || this.createNewVessel(message.mmsi);

    vessel.staticInfo = {
      name: message.vesselName,
      callSign: message.callSign,
      imoNumber: message.imoNumber,
      shipType: message.shipType,
      dimensions: message.dimensions,
      destination: message.destination
    };

    this.vessels.set(message.mmsi, vessel);
  }

  // 衝突リスクアセスメント
  private assessCollisionRisk(targetVessel: VesselInfo): CollisionRisk[] {
    const risks: CollisionRisk[] = [];
    const currentPosition = targetVessel.positionHistory[targetVessel.positionHistory.length - 1];

    for (const [mmsi, vessel] of this.vessels) {
      if (mmsi === targetVessel.mmsi) continue;

      const otherPosition = vessel.positionHistory[vessel.positionHistory.length - 1];
      if (!otherPosition) continue;

      const cpa = this.calculateCPA(currentPosition, otherPosition);
      const tcpa = this.calculateTCPA(currentPosition, otherPosition);

      if (cpa.distance < 2.0 && tcpa > 0 && tcpa < 20) { // 2nm以内、20分以内
        risks.push({
          targetMMSI: mmsi,
          cpaDistance: cpa.distance,
          cpaTime: tcpa,
          riskLevel: this.calculateRiskLevel(cpa.distance, tcpa),
          recommendedAction: this.getRecommendedAction(cpa, tcpa)
        });
      }
    }

    return risks;
  }

  // CPA（Closest Point of Approach）計算
  private calculateCPA(pos1: PositionHistory, pos2: PositionHistory): CPAResult {
    // 相対位置・速度ベクトルの計算
    const relativePosition = {
      lat: pos2.position.latitude - pos1.position.latitude,
      lng: pos2.position.longitude - pos1.position.longitude
    };

    const relativeVelocity = {
      lat: pos2.sog * Math.cos(pos2.cog * Math.PI / 180) - pos1.sog * Math.cos(pos1.cog * Math.PI / 180),
      lng: pos2.sog * Math.sin(pos2.cog * Math.PI / 180) - pos1.sog * Math.sin(pos1.cog * Math.PI / 180)
    };

    // CPAまでの時間計算
    const timeToTCPA = -(relativePosition.lat * relativeVelocity.lat + relativePosition.lng * relativeVelocity.lng) /
                      (relativeVelocity.lat * relativeVelocity.lat + relativeVelocity.lng * relativeVelocity.lng);

    // CPA距離計算
    const cpaPosition = {
      lat: relativePosition.lat + relativeVelocity.lat * timeToTCPA,
      lng: relativePosition.lng + relativeVelocity.lng * timeToTCPA
    };

    const cpaDistance = Math.sqrt(cpaPosition.lat * cpaPosition.lat + cpaPosition.lng * cpaPosition.lng) * 60; // nautical miles

    return {
      distance: cpaDistance,
      timeToTCPA: timeToTCPA,
      cpaLatitude: pos1.position.latitude + cpaPosition.lat,
      cpaLongitude: pos1.position.longitude + cpaPosition.lng
    };
  }

  // Observable パターンでリアルタイム更新
  getVesselUpdates(): Observable<VesselUpdate> {
    return new Observable(observer => {
      const intervalId = setInterval(() => {
        for (const [mmsi, vessel] of this.vessels) {
          const update: VesselUpdate = {
            mmsi,
            position: vessel.positionHistory[vessel.positionHistory.length - 1],
            collisionRisks: this.assessCollisionRisk(vessel),
            status: vessel.navigationStatus
          };
          observer.next(update);
        }
      }, 1000); // 1秒間隔

      return () => clearInterval(intervalId);
    });
  }
}

interface VesselInfo {
  mmsi: number;
  positionHistory: PositionHistory[];
  staticInfo?: {
    name: string;
    callSign: string;
    imoNumber: number;
    shipType: number;
    dimensions: any;
    destination: string;
  };
  navigationStatus?: NavigationStatus;
}

interface PositionHistory {
  position: { latitude: number; longitude: number };
  timestamp: Date;
  sog: number; // Speed Over Ground
  cog: number; // Course Over Ground
}

interface CollisionRisk {
  targetMMSI: number;
  cpaDistance: number;
  cpaTime: number;
  riskLevel: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
  recommendedAction: string;
}

interface CPAResult {
  distance: number;
  timeToTCPA: number;
  cpaLatitude: number;
  cpaLongitude: number;
}

interface VesselUpdate {
  mmsi: number;
  position: PositionHistory;
  collisionRisks: CollisionRisk[];
  status?: NavigationStatus;
}

// フリート管理システムの実装例
class FleetManagementSystem {
  private vessels: Map<string, Vessel> = new Map();
  private routes: Map<string, Route> = new Map();
  private alerts: AlertManager;

  constructor() {
    this.alerts = new AlertManager();
    this.setupPerformanceMonitoring();
  }

  // 燃料効率最適化
  optimizeFuelEfficiency(vesselId: string, route: Route): OptimizationResult {
    const vessel = this.vessels.get(vesselId);
    if (!vessel) throw new Error('Vessel not found');

    const weatherData = this.getWeatherForecast(route);
    const currentConditions = this.getCurrentConditions(vessel);

    // 速度最適化の計算
    const optimalSpeeds = this.calculateOptimalSpeeds(
      vessel.specifications,
      route,
      weatherData,
      currentConditions
    );

    // 燃料消費予測
    const fuelConsumption = this.calculateFuelConsumption(
      vessel.specifications,
      optimalSpeeds,
      weatherData
    );

    return {
      recommendedSpeeds: optimalSpeeds,
      estimatedFuelConsumption: fuelConsumption,
      estimatedSavings: currentConditions.currentConsumption - fuelConsumption,
      eta: this.calculateETA(route, optimalSpeeds, weatherData)
    };
  }

  // 航路計画システム
  planRoute(
    origin: Port,
    destination: Port,
    departureTime: Date,
    constraints: RouteConstraints
  ): RoutePlan {
    // 複数の候補ルートを生成
    const candidates = this.generateRouteCandidates(origin, destination);

    // 各ルートを評価
    const evaluatedRoutes = candidates.map(route => {
      const evaluation = this.evaluateRoute(route, departureTime, constraints);
      return { route, evaluation };
    });

    // 最適ルートの選択
    const optimal = evaluatedRoutes.reduce((best, current) => 
      current.evaluation.totalScore > best.evaluation.totalScore ? current : best
    );

    return {
      selectedRoute: optimal.route,
      alternatives: evaluatedRoutes.slice(0, 3),
      weatherRisks: this.assessWeatherRisks(optimal.route, departureTime),
      portConstraints: this.checkPortConstraints(destination, optimal.route)
    };
  }

  private evaluateRoute(route: Route, departureTime: Date, constraints: RouteConstraints): RouteEvaluation {
    const weatherScore = this.calculateWeatherScore(route, departureTime);
    const fuelScore = this.calculateFuelScore(route);
    const safetyScore = this.calculateSafetyScore(route);
    const timeScore = this.calculateTimeScore(route, constraints.maxTransitTime);

    return {
      weatherScore,
      fuelScore,
      safetyScore,
      timeScore,
      totalScore: (weatherScore * 0.3 + fuelScore * 0.3 + safetyScore * 0.3 + timeScore * 0.1)
    };
  }

  // 予防保全システム
  predictiveMaintenanceAnalysis(vesselId: string): MaintenanceRecommendation[] {
    const vessel = this.vessels.get(vesselId);
    if (!vessel) return [];

    const recommendations: MaintenanceRecommendation[] = [];

    // エンジン性能分析
    const engineData = vessel.telemetry.engineData;
    const engineHealth = this.analyzeEngineHealth(engineData);

    if (engineHealth.riskLevel > 0.7) {
      recommendations.push({
        component: 'Main Engine',
        priority: 'HIGH',
        suggestedAction: 'Schedule engine inspection',
        estimatedHours: engineHealth.estimatedHoursToFailure,
        costImpact: this.calculateMaintenanceCost('engine', engineHealth.riskLevel)
      });
    }

    // 機器別診断
    for (const [component, data] of Object.entries(vessel.telemetry)) {
      const health = this.analyzeComponentHealth(component, data);
      if (health.anomalyDetected) {
        recommendations.push({
          component,
          priority: health.priority,
          suggestedAction: health.recommendation,
          estimatedHours: health.estimatedLife,
          costImpact: health.cost
        });
      }
    }

    return recommendations.sort((a, b) => this.priorityWeight(b.priority) - this.priorityWeight(a.priority));
  }

  // RxJS を使用したリアルタイムモニタリング
  private setupPerformanceMonitoring(): void {
    // 燃料消費の監視
    this.monitorFuelConsumption().pipe(
      debounceTime(5000),
      distinctUntilChanged(),
      filter(data => data.abnormalConsumption)
    ).subscribe(data => {
      this.alerts.create({
        type: 'FUEL_ANOMALY',
        vesselId: data.vesselId,
        severity: 'MEDIUM',
        message: `Unusual fuel consumption detected: ${data.consumption}L/h`
      });
    });

    // 航行警告の監視
    this.monitorNavigationWarnings().pipe(
      throttleTime(1000),
      filter(warning => warning.severity === 'HIGH')
    ).subscribe(warning => {
      this.alerts.create({
        type: 'NAVIGATION_WARNING',
        vesselId: warning.vesselId,
        severity: 'HIGH',
        message: warning.description,
        location: warning.position
      });
    });
  }

  private monitorFuelConsumption(): Observable<FuelConsumptionData> {
    return interval(5000).pipe(
      mergeMap(() => {
        const consumptionData: FuelConsumptionData[] = [];
        for (const [id, vessel] of this.vessels) {
          const consumption = this.calculateCurrentConsumption(vessel);
          const expected = this.getExpectedConsumption(vessel);

          consumptionData.push({
            vesselId: id,
            consumption,
            expected,
            abnormalConsumption: Math.abs(consumption - expected) > expected * 0.15
          });
        }
        return from(consumptionData);
      })
    );
  }
}

interface Vessel {
  id: string;
  name: string;
  specifications: VesselSpecifications;
  currentPosition: Position;
  telemetry: VesselTelemetry;
  maintenanceHistory: MaintenanceRecord[];
}

interface VesselSpecifications {
  length: number;
  beam: number;
  draft: number;
  deadweight: number;
  maxSpeed: number;
  fuelCapacity: number;
  enginePower: number;
}

interface OptimizationResult {
  recommendedSpeeds: number[];
  estimatedFuelConsumption: number;
  estimatedSavings: number;
  eta: Date;
}

interface MaintenanceRecommendation {
  component: string;
  priority: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
  suggestedAction: string;
  estimatedHours: number;
  costImpact: number;
}

interface FuelConsumptionData {
  vesselId: string;
  consumption: number;
  expected: number;
  abnormalConsumption: boolean;
}

// ECDIS システムの実装例
interface ElectronicChart {
  id: string;
  name: string;
  scale: number;
  compilationDate: Date;
  editionNumber: number;
  boundingBox: GeographicBounds;
  features: ChartFeature[];
  safetyContours: SafetyContour[];
}

interface ChartFeature {
  id: string;
  type: FeatureType;
  geometry: Geometry;
  attributes: Record<string, any>;
  symbolization: Symbolization;
}

enum FeatureType {
  COASTLINE = 'coastline',
  DEPTH_AREA = 'depth_area',
  OBSTRUCTION = 'obstruction',
  LIGHT = 'light',
  BUOY = 'buoy',
  TRAFFIC_SEPARATION = 'traffic_separation',
  RESTRICTED_AREA = 'restricted_area',
  ANCHORAGE = 'anchorage'
}

interface SafetyContour {
  depth: number;
  geometry: LineString;
  isSelected: boolean;
}

class ECDISSystem {
  private charts: Map<string, ElectronicChart> = new Map();
  private displayedCharts: ElectronicChart[] = [];
  private currentPosition: Position;
  private routePlan: RoutePlan;
  private alarms: ECDISAlarm[] = [];

  // 海図の自動選択と表示
  autoSelectCharts(position: Position, scale: number): void {
    // 現在位置に適した海図を選択
    const candidateCharts = Array.from(this.charts.values()).filter(chart => 
      this.isPositionInChart(position, chart) && 
      this.isScaleAppropriate(scale, chart.scale)
    );

    // 最適な海図を選択（最新版、最大縮尺）
    const selectedCharts = this.selectOptimalCharts(candidateCharts, position, scale);

    // 海図の読み込みと表示
    this.displayedCharts = selectedCharts;
    this.renderCharts();

    // 海図変更の記録（SOLAS要件）
    this.logChartChange(selectedCharts, position);
  }

  // 危険区域の監視
  monitorDangerAreas(): Observable<DangerAlert> {
    return interval(1000).pipe(
      map(() => this.currentPosition),
      distinctUntilChanged((prev, curr) => 
        this.calculateDistance(prev, curr) < 0.001 // 約100m
      ),
      mergeMap(position => this.checkDangerAreas(position)),
      filter(alerts => alerts.length > 0),
      mergeMap(alerts => from(alerts))
    );
  }

  private checkDangerAreas(position: Position): DangerAlert[] {
    const alerts: DangerAlert[] = [];

    for (const chart of this.displayedCharts) {
      for (const feature of chart.features) {
        // 浅海域のチェック
        if (feature.type === FeatureType.DEPTH_AREA) {
          const depth = feature.attributes.depth as number;
          if (depth < this.getMinSafeDepth() && this.isPositionInFeature(position, feature)) {
            alerts.push({
              type: 'SHALLOW_WATER',
              severity: 'HIGH',
              message: `Entering shallow water: ${depth}m depth`,
              position,
              feature
            });
          }
        }

        // 障害物のチェック
        if (feature.type === FeatureType.OBSTRUCTION) {
          const distance = this.calculateDistanceToFeature(position, feature);
          if (distance < 0.5) { // 0.5nm以内
            alerts.push({
              type: 'OBSTRUCTION',
              severity: 'CRITICAL',
              message: `Approaching obstruction: ${distance.toFixed(2)}nm`,
              position,
              feature
            });
          }
        }

        // 制限区域のチェック
        if (feature.type === FeatureType.RESTRICTED_AREA) {
          if (this.isPositionInFeature(position, feature)) {
            alerts.push({
              type: 'RESTRICTED_AREA',
              severity: 'MEDIUM',
              message: `Entering restricted area: ${feature.attributes.name}`,
              position,
              feature
            });
          }
        }
      }
    }

    return alerts;
  }

  // 航路計画の安全性チェック
  validateRoutePlan(route: RoutePlan): RouteValidationResult {
    const violations: RouteViolation[] = [];
    const warnings: RouteWarning[] = [];

    // 各レグの安全性チェック
    for (let i = 0; i < route.waypoints.length - 1; i++) {
      const start = route.waypoints[i];
      const end = route.waypoints[i + 1];
      const leg = this.createRouteLeg(start, end);

      // 海図カバレッジのチェック
      if (!this.isRouteFullyCovered(leg)) {
        warnings.push({
          type: 'CHART_COVERAGE',
          message: 'Route partially outside chart coverage',
          legIndex: i
        });
      }

      // 浅海域の確認
      const shallowAreas = this.getShallowAreasOnRoute(leg);
      if (shallowAreas.length > 0) {
        violations.push({
          type: 'SHALLOW_WATER',
          message: `Route crosses shallow areas (min depth: ${Math.min(...shallowAreas.map(a => a.depth))}m)`,
          legIndex: i,
          severity: 'HIGH'
        });
      }

      // 制限区域の確認
      const restrictedAreas = this.getRestrictedAreasOnRoute(leg);
      if (restrictedAreas.length > 0) {
        violations.push({
          type: 'RESTRICTED_AREA',
          message: `Route crosses restricted areas`,
          legIndex: i,
          severity: 'MEDIUM'
        });
      }
    }

    return {
      isValid: violations.length === 0,
      violations,
      warnings,
      recommendations: this.generateRouteRecommendations(violations, warnings)
    };
  }

  // ECDIS設定管理
  configureDisplay(settings: ECDISDisplaySettings): void {
    // 安全設定（SOLAS A.232(82)要件準拠）
    this.setSafetyDepth(settings.safetyDepth);
    this.setSafetyContour(settings.safetyContour);
    this.setDeepContour(settings.deepContour);

    // 表示設定
    this.setDisplayMode(settings.displayMode);
    this.setColourScheme(settings.colourScheme);
    this.setSymbolSet(settings.symbolSet);

    // アラーム設定
    this.configureAlarms(settings.alarmSettings);

    // 設定変更のログ記録
    this.logSettingsChange(settings);
  }

  // 海図更新システム
  updateCharts(): Observable<ChartUpdateStatus> {
    return this.checkForUpdates().pipe(
      mergeMap(updates => {
        if (updates.length === 0) {
          return of({ status: 'UP_TO_DATE', updates: [] });
        }

        return this.downloadUpdates(updates).pipe(
          map(progress => ({
            status: 'UPDATING' as const,
            updates,
            progress
          }))
        );
      }),
      catchError(error => {
        return of({
          status: 'ERROR' as const,
          error: error.message,
          updates: []
        });
      })
    );
  }

  private downloadUpdates(updates: ChartUpdate[]): Observable<UpdateProgress> {
    return new Observable(observer => {
      let completedCount = 0;
      const totalCount = updates.length;

      updates.forEach((update, index) => {
        this.downloadSingleUpdate(update).subscribe({
          next: progress => {
            observer.next({
              overall: (completedCount + progress.percentage / 100) / totalCount,
              current: progress,
              updateIndex: index
            });
          },
          complete: () => {
            completedCount++;
            if (completedCount === totalCount) {
              observer.complete();
            }
          },
          error: error => observer.error(error)
        });
      });
    });
  }
}

interface Position {
  latitude: number;
  longitude: number;
}

interface GeographicBounds {
  north: number;
  south: number;
  east: number;
  west: number;
}

interface DangerAlert {
  type: 'SHALLOW_WATER' | 'OBSTRUCTION' | 'RESTRICTED_AREA';
  severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
  message: string;
  position: Position;
  feature: ChartFeature;
}

interface RouteValidationResult {
  isValid: boolean;
  violations: RouteViolation[];
  warnings: RouteWarning[];
  recommendations: string[];
}

interface RouteViolation {
  type: string;
  message: string;
  legIndex: number;
  severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
}

interface ECDISDisplaySettings {
  safetyDepth: number;
  safetyContour: number;
  deepContour: number;
  displayMode: 'DAY' | 'DUSK' | 'NIGHT';
  colourScheme: string;
  symbolSet: string;
  alarmSettings: AlarmSettings;
}

interface ChartUpdate {
  chartId: string;
  currentEdition: number;
  newEdition: number;
  updateType: 'NEW_EDITION' | 'WEEKLY_UPDATE' | 'NOTICE_TO_MARINERS';
  size: number;
  url: string;
}

interface UpdateProgress {
  overall: number;
  current: { percentage: number; chartId: string };
  updateIndex: number;
}

// 海洋気象統合システム
interface MarineWeatherData {
  timestamp: Date;
  position: Position;
  windSpeed: number;        // knots
  windDirection: number;    // degrees
  waveHeight: number;       // meters
  wavePeriod: number;       // seconds
  waveDirection: number;    // degrees
  swellHeight?: number;     // meters
  swellPeriod?: number;     // seconds
  visibility: number;       // nautical miles
  airTemperature: number;   // Celsius
  waterTemperature: number; // Celsius
  barometricPressure: number; // hPa
  currentSpeed?: number;    // knots
  currentDirection?: number; // degrees
}

interface WeatherRoute {
  waypoints: Array<{
    position: Position;
    eta: Date;
    weather: MarineWeatherData;
    forecast: MarineWeatherData[];
  }>;
  totalDistance: number;
  estimatedDuration: number;
  weatherRisk: WeatherRiskAssessment;
}

class MarineWeatherSystem {
  private weatherProviders: WeatherProvider[] = [];
  private forecastModels: ForecastModel[] = [];

  constructor() {
    this.initializeProviders();
    this.setupForecastModels();
  }

  // 複数ソースからのデータ統合
  async getIntegratedForecast(
    position: Position,
    timeRange: { start: Date; end: Date }
  ): Promise<MarineWeatherData[]> {
    // 複数のデータソースから予報を取得
    const forecastPromises = this.weatherProviders.map(provider => 
      provider.getForecast(position, timeRange)
    );

    const forecasts = await Promise.allSettled(forecastPromises);
    const successfulForecasts = forecasts
      .filter((result): result is PromiseFulfilledResult<MarineWeatherData[]> => 
        result.status === 'fulfilled'
      )
      .map(result => result.value);

    // アンサンブル予測
    return this.generateEnsembleForecast(successfulForecasts);
  }

  private generateEnsembleForecast(forecasts: MarineWeatherData[][]): MarineWeatherData[] {
    if (forecasts.length === 0) return [];

    const timeStamps = this.getCommonTimeStamps(forecasts);
    const ensembleForecast: MarineWeatherData[] = [];

    for (const timestamp of timeStamps) {
      const dataPoints = forecasts.map(forecast => 
        forecast.find(point => point.timestamp.getTime() === timestamp.getTime())
      ).filter(point => point !== undefined) as MarineWeatherData[];

      if (dataPoints.length > 0) {
        ensembleForecast.push({
          timestamp,
          position: dataPoints[0].position,
          windSpeed: this.calculateWeightedAverage(dataPoints.map(d => d.windSpeed)),
          windDirection: this.calculateCircularAverage(dataPoints.map(d => d.windDirection)),
          waveHeight: this.calculateWeightedAverage(dataPoints.map(d => d.waveHeight)),
          wavePeriod: this.calculateWeightedAverage(dataPoints.map(d => d.wavePeriod)),
          waveDirection: this.calculateCircularAverage(dataPoints.map(d => d.waveDirection)),
          visibility: this.calculateWeightedAverage(dataPoints.map(d => d.visibility)),
          airTemperature: this.calculateWeightedAverage(dataPoints.map(d => d.airTemperature)),
          waterTemperature: this.calculateWeightedAverage(dataPoints.map(d => d.waterTemperature)),
          barometricPressure: this.calculateWeightedAverage(dataPoints.map(d => d.barometricPressure))
        });
      }
    }

    return ensembleForecast;
  }

  // ウェザールーティング
  async optimizeRoute(
    origin: Position,
    destination: Position,
    departureTime: Date,
    vesselSpecs: VesselSpecifications
  ): Promise<WeatherRoute[]> {
    // 複数の候補ルートを生成
    const candidates = this.generateRouteCandidates(origin, destination);

    // 各ルートの気象評価
    const evaluatedRoutes: WeatherRoute[] = [];

    for (const route of candidates) {
      const routeWeather = await this.getRouteWeather(route, departureTime);
      const riskAssessment = this.assessRouteRisk(routeWeather, vesselSpecs);
      const optimizedRoute = this.optimizeRouteSpeed(route, routeWeather, vesselSpecs);

      evaluatedRoutes.push({
        ...optimizedRoute,
        weatherRisk: riskAssessment
      });
    }

    // リスクスコアでソート
    return evaluatedRoutes.sort((a, b) => a.weatherRisk.totalScore - b.weatherRisk.totalScore);
  }

  private assessRouteRisk(
    routeWeather: MarineWeatherData[],
    vesselSpecs: VesselSpecifications
  ): WeatherRiskAssessment {
    let windRisk = 0;
    let waveRisk = 0;
    let visibilityRisk = 0;
    let overallRisk = 0;

    for (const weather of routeWeather) {
      // 風速リスク
      if (weather.windSpeed > vesselSpecs.maxSafeWindSpeed) {
        windRisk += (weather.windSpeed - vesselSpecs.maxSafeWindSpeed) / vesselSpecs.maxSafeWindSpeed;
      }

      // 波高リスク
      if (weather.waveHeight > vesselSpecs.maxSafeWaveHeight) {
        waveRisk += (weather.waveHeight - vesselSpecs.maxSafeWaveHeight) / vesselSpecs.maxSafeWaveHeight;
      }

      // 視程リスク
      if (weather.visibility < 2.0) { // 2海里未満
        visibilityRisk += (2.0 - weather.visibility) / 2.0;
      }
    }

    overallRisk = (windRisk + waveRisk + visibilityRisk) / routeWeather.length;

    return {
      totalScore: overallRisk,
      windRisk: windRisk / routeWeather.length,
      waveRisk: waveRisk / routeWeather.length,
      visibilityRisk: visibilityRisk / routeWeather.length,
      recommendations: this.generateRiskRecommendations(overallRisk, windRisk, waveRisk, visibilityRisk)
    };
  }

  // リアルタイム気象監視
  monitorWeatherConditions(): Observable<WeatherAlert> {
    return interval(300000).pipe( // 5分間隔
      mergeMap(() => this.getCurrentWeather()),
      map(weather => this.evaluateWeatherConditions(weather)),
      filter(evaluation => evaluation.alertLevel > 0),
      map(evaluation => this.createWeatherAlert(evaluation))
    );
  }

  private evaluateWeatherConditions(weather: MarineWeatherData): WeatherEvaluation {
    let alertLevel = 0;
    const issues: string[] = [];

    // 強風チェック
    if (weather.windSpeed > 40) {
      alertLevel = Math.max(alertLevel, 3); // HIGH
      issues.push(`Strong winds: ${weather.windSpeed} knots`);
    } else if (weather.windSpeed > 30) {
      alertLevel = Math.max(alertLevel, 2); // MEDIUM
      issues.push(`Moderate winds: ${weather.windSpeed} knots`);
    }

    // 高波チェック
    if (weather.waveHeight > 6) {
      alertLevel = Math.max(alertLevel, 3); // HIGH
      issues.push(`High waves: ${weather.waveHeight}m`);
    } else if (weather.waveHeight > 4) {
      alertLevel = Math.max(alertLevel, 2); // MEDIUM
      issues.push(`Moderate waves: ${weather.waveHeight}m`);
    }

    // 視程チェック
    if (weather.visibility < 0.5) {
      alertLevel = Math.max(alertLevel, 3); // HIGH
      issues.push(`Very poor visibility: ${weather.visibility}nm`);
    } else if (weather.visibility < 2) {
      alertLevel = Math.max(alertLevel, 2); // MEDIUM
      issues.push(`Poor visibility: ${weather.visibility}nm`);
    }

    return { alertLevel, issues, weather };
  }
}

interface WeatherProvider {
  name: string;
  getForecast(position: Position, timeRange: { start: Date; end: Date }): Promise<MarineWeatherData[]>;
  getCurrentWeather(position: Position): Promise<MarineWeatherData>;
}

interface ForecastModel {
  name: string;
  resolution: number; // km
  timeStep: number;   // hours
  forecastHours: number;
}

interface WeatherRiskAssessment {
  totalScore: number;
  windRisk: number;
  waveRisk: number;
  visibilityRisk: number;
  recommendations: string[];
}

interface WeatherAlert {
  type: 'WIND' | 'WAVE' | 'VISIBILITY' | 'STORM';
  severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
  message: string;
  position: Position;
  affectedArea: Position[];
  validUntil: Date;
}

interface WeatherEvaluation {
  alertLevel: number;
  issues: string[];
  weather: MarineWeatherData;
}

// 港湾コミュニティシステムの実装
interface PortCall {
  id: string;
  vessel: VesselInfo;
  voyageNumber: string;
  eta: Date;
  etd: Date;
  berthRequest: BerthRequest;
  services: PortService[];
  status: PortCallStatus;
  stakeholders: Stakeholder[];
}

interface BerthRequest {
  preferredBerth?: string;
  berthType: BerthType;
  arrivalCondition: ArrivalCondition;
  departureCondition: DepartureCondition;
  specialRequirements: string[];
}

enum PortCallStatus {
  PLANNED = 'planned',
  CONFIRMED = 'confirmed',
  IN_PROGRESS = 'in_progress',
  COMPLETED = 'completed',
  CANCELLED = 'cancelled'
}

enum BerthType {
  CONTAINER = 'container',
  BULK = 'bulk',
  TANKER = 'tanker',
  PASSENGER = 'passenger',
  GENERAL_CARGO = 'general_cargo'
}

class PortCommunitySystem {
  private portCalls: Map<string, PortCall> = new Map();
  private berths: Map<string, Berth> = new Map();
  private resources: Map<string, PortResource> = new Map();
  private notifications: NotificationService;

  constructor() {
    this.notifications = new NotificationService();
    this.setupAutomatedProcesses();
  }

  // 入港計画の最適化
  optimizeBerthAllocation(timeWindow: { start: Date; end: Date }): BerthAllocationPlan {
    const scheduledCalls = Array.from(this.portCalls.values())
      .filter(call => 
        call.eta >= timeWindow.start && 
        call.eta <= timeWindow.end &&
        call.status !== PortCallStatus.CANCELLED
      );

    // 制約条件の設定
    const constraints = {
      berthCapacity: this.getBerthCapacities(),
      tideConstraints: this.getTideConstraints(timeWindow),
      pilotAvailability: this.getPilotAvailability(timeWindow),
      tugAvailability: this.getTugAvailability(timeWindow)
    };

    // 最適化アルゴリズム実行
    const allocation = this.runAllocationOptimization(scheduledCalls, constraints);

    return {
      allocations: allocation,
      efficiency: this.calculateEfficiency(allocation),
      conflicts: this.detectConflicts(allocation),
      recommendations: this.generateRecommendations(allocation)
    };
  }

  private runAllocationOptimization(
    calls: PortCall[],
    constraints: AllocationConstraints
  ): BerthAllocation[] {
    const allocations: BerthAllocation[] = [];

    // 優先度に基づいてソート（緊急度、船型、到着順）
    const sortedCalls = calls.sort((a, b) => {
      const priorityA = this.calculateCallPriority(a);
      const priorityB = this.calculateCallPriority(b);
      return priorityB - priorityA;
    });

    for (const call of sortedCalls) {
      const suitableBerths = this.findSuitableBerths(call, constraints);

      if (suitableBerths.length > 0) {
        // 最適なバースを選択
        const optimalBerth = this.selectOptimalBerth(call, suitableBerths, allocations);
        const timeSlot = this.calculateOptimalTimeSlot(call, optimalBerth, allocations);

        allocations.push({
          portCallId: call.id,
          berthId: optimalBerth.id,
          scheduledArrival: timeSlot.start,
          scheduledDeparture: timeSlot.end,
          pilotBoarding: this.calculatePilotBoarding(timeSlot.start),
          tugAssistance: this.calculateTugRequirement(call, optimalBerth)
        });
      }
    }

    return allocations;
  }

  // Just-In-Time Arrival システム
  implementJITArrival(portCallId: string): JITRecommendation {
    const portCall = this.portCalls.get(portCallId);
    if (!portCall) throw new Error('Port call not found');

    // 現在の港湾状況を分析
    const currentStatus = this.analyzePortStatus();
    const berthAvailability = this.getBerthAvailability(portCall.berthRequest);
    const serviceReadiness = this.checkServiceReadiness(portCall.services);

    // 最適到着時刻を計算
    const optimalArrival = this.calculateOptimalArrival(
      portCall,
      currentStatus,
      berthAvailability,
      serviceReadiness
    );

    // 速度調整による燃料節約効果を計算
    const currentETA = portCall.eta;
    const speedAdjustment = this.calculateSpeedAdjustment(currentETA, optimalArrival);
    const fuelSavings = this.calculateFuelSavings(speedAdjustment, portCall.vessel);

    return {
      recommendedArrival: optimalArrival,
      speedAdjustment,
      fuelSavings,
      delayReason: this.getDelayReason(currentETA, optimalArrival),
      estimatedWaitingTime: Math.max(0, optimalArrival.getTime() - currentETA.getTime())
    };
  }

  // 港湾統計とKPI管理
  generatePortStatistics(period: StatisticsPeriod): PortStatistics {
    const calls = this.getPortCallsInPeriod(period);

    const statistics: PortStatistics = {
      period,
      totalCalls: calls.length,
      vesselTypes: this.analyzeVesselTypes(calls),
      berthUtilization: this.calculateBerthUtilization(calls, period),
      averagePortStay: this.calculateAveragePortStay(calls),
      onTimePerformance: this.calculateOnTimePerformance(calls),
      turnaroundTimes: this.calculateTurnaroundTimes(calls),
      waitingTimes: this.calculateWaitingTimes(calls),
      serviceEfficiency: this.calculateServiceEfficiency(calls),
      revenueAnalysis: this.calculateRevenue(calls)
    };

    return statistics;
  }

  // リアルタイム港湾監視
  monitorPortOperations(): Observable<PortOperationAlert> {
    return merge(
      this.monitorBerthOccupancy(),
      this.monitorServiceDelay(),
      this.monitorWeatherImpact(),
      this.monitorCongestion()
    ).pipe(
      filter(alert => alert.severity !== 'INFO'),
      tap(alert => this.notifications.send(alert))
    );
  }

  private monitorCongestion(): Observable<PortOperationAlert> {
    return interval(300000).pipe( // 5分間隔
      map(() => {
        const currentCalls = Array.from(this.portCalls.values())
          .filter(call => call.status === PortCallStatus.IN_PROGRESS);

        const congestionLevel = currentCalls.length / this.getTotalBerthCapacity();

        if (congestionLevel > 0.9) {
          return {
            type: 'CONGESTION',
            severity: 'HIGH' as const,
            message: `Port congestion at ${(congestionLevel * 100).toFixed(1)}%`,
            affectedBerths: this.getOccupiedBerths().map(b => b.id),
            recommendations: [
              'Consider delaying non-urgent arrivals',
              'Expedite cargo operations',
              'Review berth allocation efficiency'
            ]
          };
        } else if (congestionLevel > 0.8) {
          return {
            type: 'CONGESTION',
            severity: 'MEDIUM' as const,
            message: `Port utilization at ${(congestionLevel * 100).toFixed(1)}%`,
            affectedBerths: [],
            recommendations: ['Monitor upcoming arrivals closely']
          };
        }

        return null;
      }),
      filter(alert => alert !== null) as OperatorFunction<any, PortOperationAlert>
    );
  }

  // 自動化プロセスの設定
  private setupAutomatedProcesses(): void {
    // 入港24時間前の確認
    interval(3600000).pipe( // 1時間間隔
      mergeMap(() => {
        const upcomingCalls = this.getUpcomingCalls(24);
        return from(upcomingCalls);
      }),
      filter(call => !call.confirmed),
      tap(call => this.sendConfirmationRequest(call))
    ).subscribe();

    // ETAの自動更新
    interval(1800000).pipe( // 30分間隔
      mergeMap(() => {
        const activeCalls = this.getActiveCalls();
        return this.updateETAs(activeCalls);
      }),
      tap(updates => this.processETAUpdates(updates))
    ).subscribe();

    // サービス完了の自動検知
    this.monitorServiceCompletion().subscribe(completion => {
      this.updateServiceStatus(completion);
      this.checkDepartureReadiness(completion.portCallId);
    });
  }
}

interface Berth {
  id: string;
  name: string;
  type: BerthType;
  length: number;
  draft: number;
  capacity: number;
  facilities: string[];
  currentOccupant?: string;
}

interface BerthAllocation {
  portCallId: string;
  berthId: string;
  scheduledArrival: Date;
  scheduledDeparture: Date;
  pilotBoarding: Date;
  tugAssistance: TugRequirement[];
}

interface JITRecommendation {
  recommendedArrival: Date;
  speedAdjustment: {
    currentSpeed: number;
    recommendedSpeed: number;
    speedReduction: number;
  };
  fuelSavings: {
    amount: number; // liters
    cost: number;   // currency
  };
  delayReason: string;
  estimatedWaitingTime: number; // milliseconds
}

interface PortStatistics {
  period: StatisticsPeriod;
  totalCalls: number;
  vesselTypes: VesselTypeAnalysis;
  berthUtilization: BerthUtilizationData;
  averagePortStay: number; // hours
  onTimePerformance: number; // percentage
  turnaroundTimes: TurnaroundAnalysis;
  waitingTimes: WaitingTimeAnalysis;
  serviceEfficiency: ServiceEfficiencyData;
  revenueAnalysis: RevenueData;
}

interface PortOperationAlert {
  type: 'CONGESTION' | 'DELAY' | 'WEATHER' | 'RESOURCE_SHORTAGE';
  severity: 'INFO' | 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
  message: string;
  affectedBerths: string[];
  recommendations: string[];
}