# 代理系统重构方案

## 文档概述

本文档定义了代理系统的核心规则和实现逻辑，包括：
- **代理等级体系**：普通、黄金、钻石三个等级
- **团队结构规则**：上下级关系约束、升级规则、团队统计
- **业务推广规则**：价格体系、收益分配规则
- **升级机制**：升级方式、费用规则、返佣规则
- **核心算法**：团队统计、收益分配、升级流程等业务逻辑伪代码

## 一、代理等级体系

### 1.1 等级定义
- **普通代理**（Level 1）：初始等级
- **黄金代理**（Level 2）：中级等级
- **钻石代理**（Level 3）：最高等级，团队首领

### 1.2 等级数值映射
```javascript
代理等级 = {
  普通: 1,
  黄金: 2,
  钻石: 3
}
```

## 二、团队结构规则

### 2.1 团队定义
- **团队**：由一个钻石代理作为首领，及其所有下级代理组成的层级关系链
- **团队首领**：必须是钻石代理，每个团队有且仅有一个首领
- **团队关系**：从普通到钻石的完整链路属于同一个团队

### 2.2 上下级关系规则

#### 2.2.1 直接上下级约束
- **核心原则**：
  1. **下级不能比上级等级高**：下级等级必须 ≤ 上级等级
  2. **同级不能作为上下级**（除了普通代理）：黄金和钻石不能作为同级上下级
- **允许关系**：
  - 普通 → 普通 ✓（同级普通允许）
  - 黄金 → 普通 ✓（上级等级高于下级，允许）
  - 钻石 → 普通 ✓（上级等级高于下级，允许）
  - 钻石 → 黄金 ✓（上级等级高于下级，允许）
- **禁止关系**：
  - 普通 → 黄金 ✗（下级等级高于上级，禁止）
  - 普通 → 钻石 ✗（下级等级高于上级，禁止）
  - 黄金 → 黄金 ✗（同级不能作为上下级）
  - 钻石 → 钻石 ✗（同级不能作为上下级）
  - 黄金 → 钻石 ✗（下级等级高于上级，禁止）

#### 2.2.2 升级规则

**核心规则**：代理升级后，其所有下级（直接+间接）会跟随该代理。

1. **普通 → 黄金**：
   - **升级后必须脱离直接上级关系**（因为黄金等级高于普通，或与黄金同级，或钻石→黄金禁止）
   - 保留团队关系（通过团队首领钻石代理）
   - 仍属于原团队
   - **下级跟随**：所有下级（直接+间接）继续跟随该代理

2. **黄金 → 钻石**：
   - 独立成为新团队
   - 成为新团队的首领
   - **下级跟随**：所有下级（直接+间接）跟随该代理到新团队

3. **普通 → 钻石**：
   - 独立成为新团队
   - 成为新团队的首领
   - **下级跟随**：所有下级（直接+间接）跟随该代理到新团队

#### 2.2.3 升级方法和费用规则

**升级方式**：

1. **钻石代理升级下级**：
   - 钻石代理可以将下级的普通代理升级为黄金代理
   - 升级方式：钻石代理操作，无需被升级代理付费

2. **代理自主付费升级**：
   - 普通代理可以付费升级为黄金代理
   - 普通代理可以付费升级为钻石代理
   - 黄金代理可以付费升级为钻石代理

**升级费用和返佣规则**：

| 升级类型                  | 升级费用 | 直接上级返佣 | 说明                             |
| ------------------------- | -------- | ------------ | -------------------------------- |
| 普通→黄金                 | 199元    | 139元        | 付费后立即返佣给直接上级         |
| 普通→钻石                 | 980元    | 680元        | 付费后立即返佣给直接上级         |
| 黄金→钻石                 | 980元    | 680元        | 付费后立即返佣给直接上级         |
| 钻石升级下级（普通→黄金） | 免费     | 无           | 钻石代理操作，被升级代理无需付费 |

**重要规则**：
- ✅ **返佣给原直接上级**：即使升级后脱离直接上下级关系，返佣仍然给原直接上级
- ✅ **返佣时机**：付费成功后立即返佣，然后执行升级操作
- ✅ **升级流程**：付费 → 返佣给直接上级 → 升级 → 根据情况脱离关系

**升级流程示例**：

**场景1：普通代理付费升级为黄金**
```
升级前：钻石D → 普通A → 普通B
流程：
1. 普通B支付199元
2. 普通A获得139元返佣（原直接上级）
3. 普通B升级为黄金
4. 黄金B脱离普通A的直接关系（因为黄金等级高于普通，下级不能比上级等级高）
5. 黄金B仍属于钻石D的团队
结果：钻石D → 普通A（获得139元返佣）
      → 黄金B（支付199元，脱离A的直接关系）
```

**场景1-2：普通代理付费升级为黄金（直接上级是黄金/钻石）**
```
升级前：钻石D → 黄金A → 普通B
流程：
1. 普通B支付199元
2. 黄金A获得139元返佣（原直接上级）
3. 普通B升级为黄金
4. 黄金B脱离黄金A的直接关系（因为黄金 → 黄金是禁止的，同级不能作为上下级）
5. 黄金B仍属于钻石D的团队
结果：钻石D → 黄金A（获得139元返佣）
      → 黄金B（支付199元，脱离A的直接关系）
```

**场景2：普通代理付费升级为钻石**
```
升级前：钻石D → 普通A → 普通B
流程：
1. 普通B支付980元
2. 普通A获得680元返佣（原直接上级）
3. 普通B升级为钻石
4. 钻石B独立成新团队（脱离普通A的直接关系）
5. 钻石B的下级跟随到新团队
结果：钻石D → 普通A（获得680元返佣）
      钻石B（新团队，支付980元）
```

**场景3：钻石代理升级下级**
```
升级前：钻石D → 普通A → 普通B
流程：
1. 钻石D操作，将普通B升级为黄金
2. 无需付费
3. 普通B升级为黄金
4. 黄金B脱离普通A的直接关系（因为黄金等级高于普通，下级不能比上级等级高）
5. 黄金B仍属于钻石D的团队
结果：钻石D → 普通A
      → 黄金B（免费升级，脱离A的直接关系）
```

**场景3-2：钻石代理升级下级（直接上级是黄金/钻石）**
```
升级前：钻石D → 黄金A → 普通B
流程：
1. 钻石D操作，将普通B升级为黄金
2. 无需付费
3. 普通B升级为黄金
4. 黄金B脱离黄金A的直接关系（因为黄金 → 黄金是禁止的，同级不能作为上下级）
5. 黄金B仍属于钻石D的团队
结果：钻石D → 黄金A
      → 黄金B（免费升级，脱离A的直接关系）
```

**返佣规则总结**：
- 返佣金额 = 升级费用 × 返佣比例
  - 普通→黄金：139元 = 199元 × 69.8%
  - 升级为钻石：680元 = 980元 × 69.4%
- 返佣对象：原直接上级（即使升级后脱离关系）
- 返佣时机：付费成功后立即返佣，然后执行升级

### 2.3 团队结构树状图示例

以下是从钻石代理作为团队首领的各种层级组合情况：

#### 2.3.1 基础层级结构

**场景1：钻石 → 普通 → 普通 → 普通**
```
钻石D (团队首领)
└── 普通A
    └── 普通B
        └── 普通C
```

**场景2：钻石 → 黄金 → 普通**
```
钻石D (团队首领)
└── 黄金A
    └── 普通B
```

**场景3：钻石 → 普通 → 钻石（新团队）**
```
钻石D (团队1首领)
└── 普通A
    └── 钻石B (团队2首领，独立新团队)
```

**场景4：钻石 → 黄金 → 普通**
```
钻石D (团队首领)
└── 黄金A
    └── 普通B
```

**场景5：钻石 → 黄金 → 钻石（新团队）**
```
钻石D (团队1首领)
└── 黄金A
    └── 钻石B (团队2首领，独立新团队)
```

#### 2.3.2 复杂多分支结构

**场景6：钻石下多个分支**
```
钻石D (团队首领)
├── 普通A
│   ├── 普通B
│   │   └── 普通C
│   └── 普通D
├── 普通G
│   └── 普通H
├── 黄金E
│   └── 普通F
└── 黄金I
    └── 普通J
```

**场景7：多层级混合结构**
```
钻石D
├── 黄金A
│   ├── 普通A
│   │   ├── 普通E
│   │   └── 普通F
│   │       └── 普通G
│   └── 普通H
│       └── 普通I
└── 黄金B
    ├── 普通C
    │   └── 普通J
    └── 普通D
```
**说明**：此结构符合所有关系约束规则

#### 2.3.3 升级后的结构变化

**场景8：普通升级为黄金（脱离直接上级）**
```
升级前：
钻石D (团队首领)
└── 普通A
    └── 普通B
        └── 普通C

升级后（B升级为黄金，黄金等级高于普通，必须脱离A的直接关系）：
钻石D (团队首领)
├── 普通A
│   └── (B已脱离直接关系)
└── 黄金B (仍属于D的团队，但脱离A的直接关系)
    └── 普通C
```

**场景8-2：普通升级为黄金（直接上级是黄金/钻石，脱离关系）**
```
升级前：
钻石D (团队首领)
└── 黄金A
    └── 普通B
        └── 普通C

升级后（B升级为黄金，黄金 → 黄金是禁止关系，需脱离）：
钻石D (团队首领)
├── 黄金A
│   └── (B已脱离直接关系)
└── 黄金B (仍属于D的团队，但脱离A的直接关系)
    └── 普通C
```

**场景9：普通升级为钻石（独立新团队）**
```
升级前：
钻石D (团队1首领)
└── 普通A
    └── 普通B
        └── 普通C

升级后（B升级为钻石）：
钻石D (团队1首领)
└── 普通A
    └── (B已独立成新团队)

钻石B (团队2首领，新团队)
└── 普通C (跟随B到新团队)
```

**场景10：黄金升级为钻石（独立新团队）**
```
升级前：
钻石D (团队1首领)
└── 黄金A
    ├── 普通B
    └── 普通C

升级后（A升级为钻石）：
钻石D (团队1首领)
└── (A已独立成新团队)

钻石A (团队2首领，新团队)
├── 普通B (跟随A到新团队)
└── 普通C (跟随A到新团队)
```

#### 2.3.4 特殊边界情况

**场景11：普通直接升级为钻石（跳过黄金）**
```
升级前：
钻石D (团队1首领)
└── 普通A
    └── 普通B
        └── 普通C

升级后（B直接升级为钻石）：
钻石D (团队1首领)
└── 普通A
    └── (B已独立成新团队)

钻石B (团队2首领，新团队)
└── 普通C (跟随B到新团队)
```

**场景12：多级普通代理链**
```
钻石D (团队首领)
└── 普通A
    └── 普通B
        └── 普通C
            └── 普通D
                └── 普通E
```

**场景13：黄金代理下多级普通代理**
```
钻石D (团队首领)
└── 黄金A
    └── 普通B
        └── 普通C
            └── 普通D
```

#### 2.3.5 图例说明

- **钻石D**：团队首领，等级3
- **黄金A**：中级代理，等级2
- **普通A**：初始代理，等级1
- **→**：直接上下级关系
- **└──**：树状图分支线
- **├──**：树状图分支线（有后续分支）
- **团队1/团队2**：不同团队的标识

#### 2.3.6 关键规则总结

1. **团队首领**：必须是钻石代理
2. **直接关系约束**：黄金/钻石不能直接管理黄金/钻石
3. **升级影响**：
   - 普通→黄金：脱离直接上级，保留团队关系
   - 黄金→钻石：独立成新团队，下级跟随
   - 普通→钻石：独立成新团队，下级跟随
4. **团队归属**：通过向上查找钻石代理确定团队归属

### 2.4 团队查找算法
```
function findTeamLeader(agent):
  current = agent
  while current.parent exists:
    if current.level == 钻石:
      return current
    current = current.parent
  return null  // 无上级则自己就是首领
```

### 2.5 团队统计规则

#### 2.5.1 核心规则定义

**团队统计的基本概念**：
- **团队定义**：每个代理的团队 = 自己 + 所有下级（直接+间接，递归）
- **统计范围**：以代理自己为起点，向下递归包含所有下级代理
- **团队独立性**：不同代理的团队是不同的，互不干扰
- **权限统一**：所有代理（普通、黄金、钻石）的权限范围相同，都只能查看自己团队范围内的数据

**关键规则**：
1. ✅ **团队范围统一**：无论代理等级如何，团队统计范围都是"自己 + 所有下级"
2. ✅ **权限范围统一**：所有代理只能查看自己团队的数据，无法查看其他代理的团队数据
3. ✅ **升级后下级跟随**：代理升级后，其所有下级（直接+间接）会跟随该代理
4. ✅ **团队归属不变**：下级升级脱离直接关系后，不影响上级的团队归属，上级的团队归属保持不变
5. ✅ **单一上级原则**：每个代理只可能有一个上级，不可能有多个上级

#### 2.5.2 不同等级代理的团队统计

**统一规则**：所有等级的代理（普通、黄金、钻石）的团队统计规则完全相同。

| 代理等级 | 团队统计范围    | 权限范围         | 说明                                           |
| -------- | --------------- | ---------------- | ---------------------------------------------- |
| 钻石     | 自己 + 所有下级 | 只能查看自己团队 | 下级可以是普通、黄金（钻石下级会独立成新团队） |
| 黄金     | 自己 + 所有下级 | 只能查看自己团队 | 下级只能是普通（黄金下级会脱离关系）           |
| 普通     | 自己 + 所有下级 | 只能查看自己团队 | 下级只能是普通（普通不能作为黄金或钻石的上级） |

**重要说明**：
- 同一代理可能出现在多个上级的团队统计中（这是正常的）
- 例如：A的下级是B，B的下级是C，那么C会同时出现在A和B的团队统计中
- 每个代理的团队统计是独立计算的，互不影响

#### 2.5.3 升级后下级跟随规则

**核心规则**：代理升级后，其所有下级（直接+间接）会跟随该代理。

| 升级类型  | 升级前结构                   | 升级后结构                                     | 下级跟随情况      |
| --------- | ---------------------------- | ---------------------------------------------- | ----------------- |
| 普通→黄金 | 上级 → 普通A → 下级B → 下级C | 上级 → 普通A<br>黄金A → 下级B → 下级C          | B和C跟随A         |
| 黄金→钻石 | 上级 → 黄金A → 下级B → 下级C | 上级<br>钻石A（新团队）→ 下级B → 下级C         | B和C跟随A到新团队 |
| 普通→钻石 | 上级 → 普通A → 下级B → 下级C | 上级 → 普通A<br>钻石A（新团队）→ 下级B → 下级C | B和C跟随A到新团队 |

**重要说明**：
- 升级后脱离直接关系的代理，其下级会跟随该代理
- 如果升级为钻石，会独立成新团队，下级跟随到新团队
- 升级不影响上级的团队归属，上级的团队归属保持不变

#### 2.5.4 团队统计算法

```
function getTeamMembers(agent):
  // 获取代理的团队成员（包括自己和所有下级）
  team_members = [agent]  // 包括自己
  
  function collectChildren(agent):
    // 递归收集所有下级
    for each child in agent.children:  // 直接下级
      team_members.append(child)
      collectChildren(child)  // 递归收集间接下级
  
  collectChildren(agent)
  return team_members

function getTeamStatistics(agent):
  // 获取代理的团队统计数据
  team_members = getTeamMembers(agent)
  
  statistics = {
    total_count: team_members的数量,  // 团队总人数（包括自己）
    self: agent,  // 自己
    members: team_members,  // 所有成员（自己+所有下级）
    by_level: {
      钻石: 从team_members中筛选出等级为钻石的,
      黄金: 从team_members中筛选出等级为黄金的,
      普通: 从team_members中筛选出等级为普通的
    },
    direct_children: agent.children,  // 直接下级
    indirect_children: team_members中排除自己和直接下级的  // 间接下级
  }
  
  return statistics

function hasPermissionToView(agent, target_agent):
  // 检查代理是否有权限查看目标代理的数据
  if agent.id == target_agent.id:
    return true  // 可以查看自己
  
  // 检查目标代理是否是当前代理的下级
  team_members = getTeamMembers(agent)
  return target_agent是否在team_members中
```

#### 2.5.5 团队统计示例

**示例1：不同代理的团队统计范围**

```
整体结构：
钻石D
├── 普通A
│   ├── 普通B
│   └── 普通C
├── 黄金E
│   └── 普通F
└── 黄金G
    └── 普通H
```

**各代理的团队统计**：

| 代理  | 团队统计范围                     | 总计 | 说明                                             |
| ----- | -------------------------------- | ---- | ------------------------------------------------ |
| 钻石D | 自己 + A + B + C + E + F + G + H | 8人  | 包含所有下级                                     |
| 黄金E | 自己 + F                         | 2人  | 只包含自己的下级                                 |
| 黄金G | 自己 + H                         | 2人  | 只包含自己的下级                                 |
| 普通A | 自己 + B + C                     | 3人  | 只包含自己的下级（普通代理的下级只能是普通代理） |

**权限说明**：
- 钻石D只能查看自己团队（8人）的数据
- 黄金E只能查看自己团队（2人）的数据，看不到D、A、B、C、G、H的数据
- 黄金G只能查看自己团队（2人）的数据，看不到D、A、B、C、E、F的数据
- 普通A只能查看自己团队（3人）的数据，看不到D、E、F、G、H的数据

**示例2：升级后团队统计变化**

```
升级前：
钻石D → 黄金A → 普通B → 普通C

升级后（A升级为钻石，独立成新团队）：
钻石D
钻石A（新团队）→ 普通B → 普通C（B和C跟随A）
```

**升级后的团队统计**：

| 代理  | 升级前统计              | 升级后统计          | 变化说明                   |
| ----- | ----------------------- | ------------------- | -------------------------- |
| 钻石A | 自己 + B + C（3人）     | 自己 + B + C（3人） | 下级跟随，统计不变         |
| 钻石D | 自己 + A + B + C（4人） | 自己（1人）         | A独立后，不再包含A及其下级 |

**关键点**：
- A升级后，B和C跟随A到新团队
- D的团队统计不再包含A、B、C（因为A已独立）
- A的团队统计仍然包含B和C（因为下级跟随）

## 三、业务推广规则

### 3.1 价格体系

#### 3.1.1 基础底价
- **系统基础底价**：BasePrice（系统配置）

#### 3.1.2 等级加成规则
```javascript
等级加成 = {
  钻石: 0,
  黄金: 3,
  普通: 6
}
```

#### 3.1.3 实际底价计算
```
实际底价 = 基础底价 + 等级加成[代理等级]
```

#### 3.1.4 价格设定范围
- **最低价**：实际底价
- **最高价**：系统设定上限（SystemMaxPrice）
- **代理设定价格**：必须在最低价和最高价之间（包含两端），即：实际底价 ≤ 设定价格 ≤ SystemMaxPrice

### 3.2 收益分配规则

#### 3.2.1 核心分配原则

**重要规则**：
- **平台固定收入**：无论哪个等级的代理推广，平台固定收到 **基础底价（BasePrice）**
- **等级加成部分**：作为返佣分配给上级链
  - 钻石代理：等级加成 = 0，无返佣分配
  - 黄金代理：等级加成 = 3，全部作为返佣给钻石上级
  - 普通代理：等级加成 = 6，按规则分配给上级链

**分配结构**：
```
用户支付金额 = 代理设定价格
├── 代理收益 = 设定价格 - 实际底价 - 提价成本
├── 实际底价 = 基础底价 + 等级加成
    ├── 基础底价 → 平台（固定）
    └── 等级加成 → 上级链返佣（按规则分配）
```

#### 3.2.2 代理收益计算
```
提价成本 = 0
if (设定价格 > 提价标准阈值):
  提价成本 = (设定价格 - 提价标准阈值) × 提价手续费比例

代理收益 = 设定价格 - 实际底价 - 提价成本
```

#### 3.2.3 等级加成返佣分配规则

**分配算法**：

```
function distributeLevelBonus(agent):
  // 分配等级加成返佣
  levelBonus = LevelBonus[agent.level]
  
  // 钻石代理：等级加成为0，无返佣分配
  if agent.level == 钻石:
    return { platform: 0 }  // 无返佣，平台也不收这部分（因为加成本身就是0）
  
  // 黄金代理：等级加成3元，全部给钻石上级
  if agent.level == 黄金:
    diamondParent = findDiamondParent(agent)
    if diamondParent存在:
      return { [diamondParent.id]: levelBonus }  // 3元给钻石上级
    // 找不到钻石上级，返佣归平台（异常情况）
    return { platform: levelBonus }
  
  // 普通代理：等级加成6元，按规则分配给上级链
  if agent.level == 普通:
    return distributeNormalAgentBonus(agent, levelBonus)
  
  return { platform: levelBonus }

function distributeNormalAgentBonus(agent, amount):
  // 普通代理的等级加成返佣分配（6元）
  // 核心规则：
  // 1. 根据直接上级等级分配固定金额给直接上级
  // 2. 剩余金额按优先级分配给上级链：钻石优先（全部），黄金次之（最多3元），平台兜底
  
  parent = agent.parent
  if parent不存在:
    return { platform: amount }  // 无上级，全部归平台
  
  // 步骤1：给直接上级分配固定金额
  // 直接上级分配规则：钻石6元，黄金3元，普通2元
  directParentAmount = {
    钻石: 6,
    黄金: 3,
    普通: 2
  }[parent.level]
  
  result = { [parent.id]: directParentAmount }
  remaining = amount - directParentAmount  // 剩余金额
  
  // 步骤2：分配剩余金额（如果直接上级是钻石，则无剩余）
  if remaining > 0:
    // 确定查找起点：直接上级是普通时从直接上级开始查找，否则从直接上级的上级开始查找
    searchStart = parent if parent.level == 普通 else parent.parent
    
    if searchStart存在:
      // 查找上级链中的钻石和黄金
      diamondParent = findDiamondParent(searchStart)
      goldParent = findGoldParent(searchStart)
      
      // 按优先级分配剩余金额
      if diamondParent存在:
        // 优先级1：有钻石，剩余金额全部给钻石
        result[diamondParent.id] = remaining
      else if goldParent存在:
        // 优先级2：只有黄金，最多3元给黄金，剩余归平台
        goldAmount = min(remaining, 3)  // 黄金最多3元
        result[goldParent.id] = goldAmount
        if remaining > goldAmount:
          result.platform = remaining - goldAmount
      else:
        // 优先级3：都没有，剩余金额归平台
        result.platform = remaining
    else:
      // 无法查找上级链，剩余金额归平台
      result.platform = remaining
  
  return result

function findDiamondParent(agent):
  // 向上查找钻石上级
  current = agent.parent
  while current存在:
    if current.level == 钻石:
      return current
    current = current.parent
  return null

function findGoldParent(agent):
  // 向上查找黄金上级
  current = agent.parent
  while current存在:
    if current.level == 黄金:
      return current
    current = current.parent
  return null
```

#### 3.2.4 分配规则总结表

**核心原则**：
- **基础底价（BasePrice）**：无论哪个等级，全部归平台（固定收入）
- **等级加成部分**：作为返佣分配给上级链

| 代理等级 | 等级加成 | 直接上级 | 等级加成返佣分配规则                                                                                               |
| -------- | -------- | -------- | ------------------------------------------------------------------------------------------------------------------ |
| 钻石     | 0元      | 无       | 无返佣分配（加成为0）                                                                                              |
| 黄金     | 3元      | 钻石     | 3元全部给钻石上级                                                                                                  |
| 普通     | 6元      | 钻石     | 6元全部给钻石上级                                                                                                  |
| 普通     | 6元      | 黄金     | 3元给黄金上级，3元给钻石上级（上上级）                                                                             |
| 普通     | 6元      | 普通     | 2元给直接上级普通，剩余4元：<br>- 有钻石：4元全部给钻石<br>- 只有黄金：3元给黄金，1元归平台<br>- 都没有：4元归平台 |

**收益分配示例**：
- **钻石代理推广**：用户支付 = 基础底价，平台收入 = 基础底价，返佣 = 0
- **黄金代理推广**：用户支付 = 基础底价 + 3，平台收入 = 基础底价，返佣 = 3元给钻石
- **普通代理推广**：用户支付 = 基础底价 + 6，平台收入 = 基础底价，返佣 = 6元按规则分配

## 四、系统配置参数

### 4.1 价格相关
- `BasePrice`: 基础底价
- `SystemMaxPrice`: 系统价格上限
- `PriceThreshold`: 提价标准阈值
- `PriceFeeRate`: 提价手续费比例

### 4.2 分配相关
- `BasePrice`: 基础底价（固定归平台）
- `LevelBonus`: 等级加成配置
  - `钻石`: 0元
  - `黄金`: 3元（全部给钻石上级）
  - `普通`: 6元（按规则分配给上级链）
- `DirectParentAmount`: 直接上级分配金额配置
  - `普通→钻石`: 6元
  - `普通→黄金`: 3元
  - `普通→普通`: 2元
- `MaxGoldAmount`: 黄金代理最大分配金额（3元）
- `GoldToDiamondAmount`: 黄金→钻石分配金额（3元）

### 4.3 等级加成
- `LevelBonus`: { 钻石: 0, 黄金: 3, 普通: 6 }

### 4.4 升级费用和返佣
- `UpgradeFee`: 升级费用配置
  - `NormalToGold`: 199元（普通→黄金）
  - `NormalToDiamond`: 980元（普通→钻石）
  - `GoldToDiamond`: 980元（黄金→钻石）
- `UpgradeRebate`: 升级返佣配置
  - `NormalToGoldRebate`: 139元（普通→黄金，给直接上级）
  - `ToDiamondRebate`: 680元（升级为钻石，给直接上级）
- `UpgradeRebateRate`: 升级返佣比例
  - `NormalToGoldRate`: 69.8%（139/199）
  - `ToDiamondRate`: 69.4%（680/980）

## 五、核心算法伪代码

### 6.1 计算实际底价
```
function calculateActualBasePrice(agentLevel, basePrice):
  levelBonus = LevelBonus[agentLevel]
  return basePrice + levelBonus
```

### 6.2 计算代理收益
```
function calculateAgentProfit(setPrice, actualBasePrice, priceThreshold, feeRate):
  priceCost = 0
  if setPrice > priceThreshold:
    priceCost = (setPrice - priceThreshold) × feeRate
  return setPrice - actualBasePrice - priceCost
```

### 6.3 收益分配主流程
```
function distributeRevenue(agent, setPrice, basePrice):
  // 1. 计算实际底价
  levelBonus = LevelBonus[agent.level]
  actualBasePrice = basePrice + levelBonus
  
  // 2. 计算代理收益
  priceCost = calculatePriceCost(setPrice)
  agentProfit = setPrice - actualBasePrice - priceCost
  
  // 3. 基础底价部分：全部归平台（固定）
  platformRevenue = basePrice
  
  // 4. 等级加成部分：按规则分配给上级链
  levelBonusDistribution = distributeLevelBonus(agent)
  
  // 5. 汇总分配结果
  return {
    agentProfit: agentProfit,
    platformRevenue: platformRevenue,
    levelBonusDistribution: levelBonusDistribution
  }
```

### 6.4 等级加成返佣分配流程
```
function distributeLevelBonus(agent):
  levelBonus = LevelBonus[agent.level]
  
  if agent.level == 钻石:
    return {}  // 无返佣（加成为0）
  
  if agent.level == 黄金:
    diamondParent = findDiamondParent(agent)
    return { [diamondParent.id]: levelBonus }  // 3元给钻石
  
  if agent.level == 普通:
    return distributeNormalAgentBonus(agent, levelBonus)  // 6元按规则分配
```

### 6.5 代理升级流程
```
function upgradeAgent(agent, targetLevel, upgradeType):
  // 参数说明：
  // agent: 被升级的代理
  // targetLevel: 目标等级（2=黄金, 3=钻石）
  // upgradeType: 'self_paid'（自主付费）or 'diamond_upgrade'（钻石升级）
  
  // 1. 验证升级条件
  if not canUpgrade(agent, targetLevel, upgradeType):
    return { error: '升级条件不满足' }
  
  // 2. 如果是自主付费升级，处理付费
  if upgradeType == 'self_paid':
    upgradeFee = getUpgradeFee(agent.level, targetLevel)
    rebateAmount = getUpgradeRebate(agent.level, targetLevel)
    originalParent = agent.parent
    
    // 2.1 代理付费
    paymentResult = processPayment(agent, upgradeFee)
    if not paymentResult.success:
      return { error: '付费失败' }
    
    // 2.2 返佣给原直接上级（即使升级后脱离关系）
    if originalParent:
      rebateResult = processRebate(originalParent, rebateAmount)
      if not rebateResult.success:
        // 如果返佣失败，需要退款
        refundPayment(agent, upgradeFee)
        return { error: '返佣失败，已退款' }
  
  // 3. 执行升级操作
  agent.level = targetLevel
  
  // 4. 检查是否需要脱离直接上级关系
  if needDetachFromParent(agent, agent.parent):
    agent.parent = null  // 脱离直接关系
    // 但保留团队关系（通过钻石首领）
  
  // 5. 如果升级为钻石，独立成新团队
  if targetLevel == 钻石:
    agent.teamLeaderId = agent.id  // 成为新团队首领
    // 下级会跟随（已在升级规则中定义）
  
  return { success: true, agent: agent }

function canUpgrade(agent, targetLevel, upgradeType):
  // 检查升级条件
  if upgradeType == 'diamond_upgrade':
    // 钻石升级下级：必须是钻石操作，且下级是普通代理
    return agent.level == 普通 and targetLevel == 黄金
  else if upgradeType == 'self_paid':
    // 自主付费：普通可以升级为黄金或钻石，黄金可以升级为钻石
    if agent.level == 普通:
      return targetLevel == 黄金 or targetLevel == 钻石
    else if agent.level == 黄金:
      return targetLevel == 钻石
  return false

function getUpgradeFee(fromLevel, toLevel):
  if fromLevel == 普通 and toLevel == 黄金:
    return 199
  else if toLevel == 钻石:
    return 980
  return 0

function getUpgradeRebate(fromLevel, toLevel):
  if fromLevel == 普通 and toLevel == 黄金:
    return 139
  else if toLevel == 钻石:
    return 680
  return 0

function needDetachFromParent(agent, parent):
  // 检查是否需要脱离直接上级关系
  // 规则1：下级不能比上级等级高
  // 规则2：同级不能作为上下级（除了普通代理）
  if not parent:
    return false
  
  // 如果代理等级高于上级等级，必须脱离
  if agent.level > parent.level:
    return true
  
  // 同级不能作为上下级（除了普通代理）
  if agent.level == parent.level:
    if agent.level == 黄金 or agent.level == 钻石:
      return true  // 黄金 → 黄金、钻石 → 钻石禁止
  
  // 钻石 → 黄金禁止（虽然钻石等级高于黄金，但这是特殊禁止规则）
  if agent.level == 黄金 and parent.level == 钻石:
    return true
  
  return false
```

## 六、业务流程图

### 7.1 代理升级流程

#### 7.1.1 自主付费升级流程
```
代理发起升级请求
  ↓
检查升级条件（等级、权限等）
  ↓
计算升级费用和返佣金额
  ↓
代理支付升级费用
  ↓
付费成功后，立即返佣给原直接上级
  ↓
执行升级操作（更新代理等级）
  ↓
检查是否需要脱离直接上级关系
  ↓
如果升级为钻石
  → 独立成新团队
  → 成为团队首领
  → 下级跟随到新团队
  ↓
完成升级
```

#### 7.1.2 钻石升级下级流程
```
钻石代理操作升级下级
  ↓
检查升级条件（必须是普通代理升级为黄金）
  ↓
无需付费，直接执行升级操作
  ↓
检查是否需要脱离直接上级关系
  ↓
完成升级
```

#### 7.1.3 升级费用和返佣流程
```
升级费用表：
- 普通→黄金：199元，返佣139元给直接上级
- 普通→钻石：980元，返佣680元给直接上级
- 黄金→钻石：980元，返佣680元给直接上级

返佣规则：
- 返佣对象：原直接上级（即使升级后脱离关系）
- 返佣时机：付费成功后立即返佣
- 返佣金额：固定金额，不随升级后关系变化而改变
```

### 7.2 业务推广收益分配流程
```
用户付费查询（支付代理设定价格）
  ↓
计算实际底价 = 基础底价 + 等级加成
  ↓
计算代理收益 = 设定价格 - 实际底价 - 提价成本
  ↓
收益分配：
  ├── 基础底价部分 → 平台（固定收入）
  └── 等级加成部分 → 按规则分配给上级链
      ├── 钻石代理：加成=0，无返佣
      ├── 黄金代理：加成=3，全部给钻石上级
      └── 普通代理：加成=6，按规则分配给上级链
```

## 七、边界情况处理

1. **钻石代理有上级**：理论上不应存在，但系统需处理异常情况
2. **团队链断裂**：如果上级链中找不到钻石代理，剩余金额归平台
3. **价格异常**：设定价格低于实际底价时，拒绝交易
4. **升级冲突**：升级时检查是否违反直接上下级约束规则
5. **升级关系判断**：
   - 普通 → 黄金升级时，必须脱离直接上级关系
   - 原因：黄金等级高于普通（下级不能比上级等级高），或与黄金同级（同级不能作为上下级），或钻石→黄金禁止
   - 普通/黄金 → 钻石升级时，独立成新团队，脱离所有上级关系
6. **返佣处理**：返佣给原直接上级，即使升级后脱离关系，返佣不受影响
7. **团队统计更新**：所有关系变更后，需要正确更新团队统计范围
