int speed = 500;
float altitude = speed;  // 암묵적 형변환 - 경고만 나올 수도
char* message = (char*)speed;  // 강제 형변환 - 위험!

type Meters is new Float;
type Feet is new Float;

Distance_M : Meters := 100.0;
Distance_F : Feet := Distance_M;  -- ❌ 컴파일 에러!
-- "Meters와 Feet는 다른 타입입니다!"

type Percentage is range 0 .. 100;
type Engine_RPM is range 0 .. 10_000;

Fuel_Level : Percentage := 75;
RPM : Engine_RPM := 5000;

Fuel_Level := 150;  -- ❌ 컴파일 에러!
RPM := Fuel_Level;  -- ❌ 타입 불일치!

subtype Positive_Integer is Integer range 1 .. Integer'Last;
subtype Natural is Integer range 0 .. Integer'Last;

Array_Index : Positive_Integer;  -- 절대 0이나 음수가 될 수 없음!

procedure Process_Array(Size : Positive_Integer) is
  Data : array(1 .. Size) of Float;  -- 크기가 항상 양수임을 보장
begin
  -- 안전한 배열 처리
end Process_Array;

type Flight_Mode is (Takeoff, Cruise, Landing, Emergency);
type Engine_State is (Off, Idle, Normal, Maximum);

Current_Mode : Flight_Mode := Cruise;
Engine : Engine_State := Normal;

-- 이런 실수를 방지!
if Current_Mode = Engine then  -- ❌ 컴파일 에러!
  -- 완전히 다른 타입을 비교할 수 없음
end if;

task type Radar_Monitor is
  pragma Priority(10);  -- 높은 우선순위
  entry Start;
  entry Stop;
end Radar_Monitor;

task body Radar_Monitor is
  Scan_Interval : constant Duration := 0.05;  -- 50ms
begin
  accept Start;
  loop
    -- 레이더 스캔 수행
    Scan_Airspace;
    
    -- 정확히 50ms 대기
    delay Scan_Interval;
    
    select
      accept Stop;
      exit;  -- 태스크 종료
    else
      null;  -- 계속 실행
    end select;
  end loop;
end Radar_Monitor;

protected type Sensor_Data is
  procedure Update(New_Value : Float);
  function Read return Float;
  entry Wait_For_Change(Value : out Float);
private
  Current_Value : Float := 0.0;
  Changed : Boolean := False;
end Sensor_Data;

protected body Sensor_Data is
  procedure Update(New_Value : Float) is
  begin
    Current_Value := New_Value;
    Changed := True;
  end Update;
  
  function Read return Float is
  begin
    return Current_Value;
  end Read;
  
  entry Wait_For_Change(Value : out Float) 
    when Changed is  -- 조건이 참일 때만 진입 가능
  begin
    Value := Current_Value;
    Changed := False;
  end Wait_For_Change;
end Sensor_Data;

procedure Critical_Operation is
  Start_Time : Time;
  Max_Duration : constant Duration := 0.1;  -- 100ms 제한
begin
  Start_Time := Clock;
  
  -- 중요한 작업 수행
  Process_Flight_Data;
  
  -- 시간 초과 검사
  if Clock - Start_Time > Max_Duration then
    raise Timing_Error with "Operation took too long!";
  end if;
end Critical_Operation;

-- 또는 타임아웃이 있는 대기
select
  Sensor.Wait_For_Data(Result);
or
  delay 0.05;  -- 50ms 타임아웃
  raise Timeout_Error;
end select;

-- A380 비행 제어 시스템 개념 예시
package Flight_Control_System is
  
  type Control_Surface is (
    Left_Aileron, Right_Aileron,
    Left_Elevator, Right_Elevator,
    Rudder, Spoilers
  );
  
  type Surface_Position is range -30.0 .. 30.0;  -- 각도 (도)
  
  protected type Surface_Controller is
    procedure Command(
      Surface : Control_Surface;
      Position : Surface_Position
    );
    function Get_Position(Surface : Control_Surface) 
      return Surface_Position;
  private
    Positions : array(Control_Surface) of Surface_Position 
      := (others => 0.0);
  end Surface_Controller;
  
  -- 3중 중복 시스템
  Primary_Controller : Surface_Controller;
  Secondary_Controller : Surface_Controller;
  Tertiary_Controller : Surface_Controller;
  
end Flight_Control_System;

-- ATV 도킹 시스템 개념 예시
package ATV_Docking_System is
  
  type Distance is range 0 .. 250_000;  -- 미터
  type Velocity is range -100 .. 100;    -- m/s
  type Docking_Phase is (
    Approach,      -- 250km ~ 30km
    Closing,       -- 30km ~ 250m
    Final_Approach,-- 250m ~ 20m
    Contact,       -- 20m ~ 0m
    Capture
  );
  
  protected type Docking_Controller is
    procedure Update_Position(
      Current_Distance : Distance;
      Current_Velocity : Velocity
    );
    function Get_Phase return Docking_Phase;
    procedure Execute_Maneuver;
  private
    Phase : Docking_Phase := Approach;
    Distance_To_ISS : Distance;
    Relative_Velocity : Velocity;
  end Docking_Controller;
  
  -- 안전 임계값
  Max_Approach_Velocity : constant Velocity := 7;  -- 7cm/s
  Abort_Distance : constant Distance := 10;  -- 10m
  
end ATV_Docking_System;

-- 이지스 시스템 개념 예시
package Aegis_Combat_System is
  
  type Target_ID is range 1 .. 200;
  type Threat_Level is (Low, Medium, High, Critical);
  type Weapon_Type is (SM2, SM3, SM6, ESSM);
  
  type Target_Info is record
    ID : Target_ID;
    Position : Coordinate_3D;
    Velocity : Vector_3D;
    Threat : Threat_Level;
    Time_To_Impact : Duration;
  end record;
  
  protected type Target_Database is
    procedure Add_Target(Info : Target_Info);
    procedure Update_Target(Info : Target_Info);
    procedure Remove_Target(ID : Target_ID);
    function Get_Highest_Threat return Target_Info;
    function Get_All_Targets return Target_Array;
  private
    Targets : Target_Array(1 .. 200);
    Count : Natural := 0;
  end Target_Database;
  
  task type Radar_Processor is
    pragma Priority(System.Priority'Last);  -- 최고 우선순위
  end Radar_Processor;
  
  task type Weapon_Controller is
    pragma Priority(System.Priority'Last - 1);
    entry Engage(Target : Target_ID; Weapon : Weapon_Type);
  end Weapon_Controller;
  
end Aegis_Combat_System;

-- F-22 센서 융합 개념 예시
package Sensor_Fusion_System is
  
  type Sensor_Type is (Radar, IRST, RWR, CNI);
  type Contact_Source is array(Sensor_Type) of Boolean;
  
  type Track_Info is record
    Position : Coordinate_3D;
    Velocity : Vector_3D;
    Confidence : Float range 0.0 .. 1.0;
    Sources : Contact_Source;
    Last_Update : Time;
  end record;
  
  protected type Fusion_Engine is
    procedure Add_Radar_Contact(Info : Track_Info);
    procedure Add_IRST_Contact(Info : Track_Info);
    procedure Add_RWR_Contact(Info : Track_Info);
    function Get_Fused_Picture return Track_Array;
  private
    procedure Correlate_Tracks;
    procedure Update_Confidence;
    Tracks : Track_Array(1 .. 100);
  end Fusion_Engine;
  
  task type Fusion_Processor is
    pragma Priority(High_Priority);
  end Fusion_Processor;
  
  task body Fusion_Processor is
    Update_Rate : constant Duration := 0.05;  -- 20Hz
  begin
    loop
      Fusion.Correlate_Tracks;
      Fusion.Update_Confidence;
      delay Update_Rate;
    end loop;
  end Fusion_Processor;
  
end Sensor_Fusion_System;

-- SPARK 예시: 형식 검증 가능한 코드
procedure Safe_Division(X, Y : Integer; Result : out Integer)
  with Pre  => Y /= 0,  -- 사전조건: Y는 0이 아님
       Post => Result = X / Y  -- 사후조건: 결과는 X/Y
is
begin
  Result := X / Y;
end Safe_Division;

-- SPARK 도구가 자동으로 검증:
-- 1. Y가 0이 아닌지 확인
-- 2. 오버플로우 가능성 확인
-- 3. 사후조건이 만족되는지 확인

// C++ 코드 - 위험한 부분들
int array[10];
int index = 15;
array[index] = 42;  // 💥 버퍼 오버플로우! 런타임에만 발견

void* ptr = malloc(100);
int* num = (int*)ptr;  // 타입 안전성 없음
free(ptr);
*num = 10;  // 💥 해제된 메모리 접근!

// 스레드 안전성도 수동으로 관리
std::mutex mtx;
int shared_data;
void update() {
  // 뮤텍스 잠그는 걸 깜빡하면? 💥
  shared_data++;
}

-- Ada 코드 - 안전장치들
type Safe_Array is array(1 .. 10) of Integer;
Array_Data : Safe_Array;
Index : Integer := 15;
Array_Data(Index) := 42;  -- ❌ 컴파일 에러 또는 런타임 예외!

-- 타입 안전한 포인터
type Int_Access is access Integer;
Ptr : Int_Access := new Integer;
Ptr.all := 10;  -- 타입 안전성 보장

-- 내장 스레드 안전성
protected Shared_Data is
  procedure Increment;
  function Get return Integer;
private
  Value : Integer := 0;
end Shared_Data;
-- 자동으로 동기화됨!

with Ada.Text_IO; use Ada.Text_IO;

procedure Hello is
begin
  Put_Line("Hello, Ada World!");
end Hello;

with Ada.Text_IO; use Ada.Text_IO;

procedure Safe_Calculator is
  type Percentage is range 0 .. 100;
  
  function Calculate_Grade(Score : Percentage) return Character is
  begin
    case Score is
      when 90 .. 100 => return 'A';
      when 80 .. 89  => return 'B';
      when 70 .. 79  => return 'C';
      when 60 .. 69  => return 'D';
      when others    => return 'F';
    end case;
  end Calculate_Grade;
  
  Student_Score : Percentage;
  Grade : Character;
begin
  Put("Enter score (0-100): ");
  Student_Score := Percentage'Value(Get_Line);
  
  Grade := Calculate_Grade(Student_Score);
  Put_Line("Grade: " & Grade);
  
exception
  when Constraint_Error =>
    Put_Line("Error: Score must be between 0 and 100!");
end Safe_Calculator;

-- Ada 2022의 새로운 기능 예시
procedure Parallel_Processing is
  type Data_Array is array(1 .. 1000) of Float;
  Input : Data_Array := (others => 0.0);
  Output : Data_Array;
begin
  -- 병렬 처리!
  for I in Input'Range with parallel => True loop
    Output(I) := Complex_Calculation(Input(I));
  end loop;
end Parallel_Processing;

-- 개선된 계약 프로그래밍
function Safe_Sqrt(X : Float) return Float
  with Pre  => X >= 0.0,
       Post => Safe_Sqrt'Result ** 2 in X * 0.99 .. X * 1.01
is
begin
  return Sqrt(X);
end Safe_Sqrt;