# module Lecture1

#==
 = 这是作业的 Julia 实现版本
==#

#==
# Fields
export field_group_id, field_student_name,
    field_student_id, field_student_class, field_data_padded
# Functions
export fetchstudent, fetchgroup, fetchclass, fetchgrade
export simplerandomsample
export id2idx
# =#

using DataFrames, CSV

# 1. <前置工作>装载分组的 CSV
#==
 = 名词解释：
 =
 = * CSV
 =      CSV，大名逗号分隔值，是以纯文本形式存储表格数据（数字和文本）
 =  的文件格式/文件。
 =      打个比方，这就是一个 CSV 文件：
 =
 = /demo.csv
 = Date,Nickname,OnlineTime,OfflineTime
 = 2023-08-05,十三,00:58,02:17
 = 2023-08-05,CXKLOVEMissC,07:12,09:05
 = 2023-08-07,momo,07:11,09:17
 =
 =     美化一下就可以这样：
 =
 = Row │ Date        NickName       OnlineTime    OfflineTime     
 =─────┼───────────────────────────────────────────────────────
 =   1 │ 2023-08-05           十三        00:58          02:17  
 =   2 │ 2023-08-05  CXKLOVEMissC        07:12          09:05
 = ... │  ...            ⋮                 ⋮               ⋮
 = 
 = * DataFrame
 =     一种以表格为主的数据结构（和文件类似但是与之不同的是其在
 = 电脑的内存而非硬盘里面）。
 =     （本想多写一点但我发现我也不大会... Orz）
 =
==#

# 组别的 DataFrame
groups = CSV.read("统计学分组.csv", DataFrame)


# 2. <前置工作>书写一些工具函数 && 检查数据

#==
 = 关于列名
 =     通过别的列名来命名的好处是，如果 CSV 文件内的列名被修改了，可以很轻松的
 = 在这里更改别名来更新相关代码。
 =     这是从软件工程角度来思考以及实现的。
==#

# 请使用 DataFrame.propertynames() 来确保是 Symbol 而非 String
field_group_id = :GroupID
field_student_name = :Name
field_student_id = :ID
field_student_class = :Class
"""数据有缺如/异常"""
field_data_padded = :Padded
# 在 DataFrame 中，需要通过 getproperty(df, property) 来实现。

"""
根据名字得到学生信息

julia> fetchstudent(groups, "ＧＥＳ")
DataFrameRow
 Row │ GroupID  Name      ID             Class     
     │ Int64    String31  Int64          String15?
─────┼─────────────────────────────────────────────
 148 │      25  ＧＥＳ    20235055*****  missing
"""
function fetchstudent(df::DataFrame, name::String)::DataFrameRow
    # {:Name => (name -> name =? name_inputed)} -> Boolean
    student_res = filter(field_student_name => nm -> nm == name, df)
    # With a new row.

    eachrow(df)[id2idx(df, getproperty(student_res[1, :], field_student_id))]
end

"""
根据序号或学号得到学生信息

julia> # Or with fetchstudent(groups, 20235055*****)
julia> fetchstudent(groups, 148)
DataFrameRow
 Row │ GroupID  Name      ID             Class     
     │ Int64    String31  Int64          String15?
─────┼─────────────────────────────────────────────
 148 │      25  ＧＥＳ    20235055*****  missing
"""
function fetchstudent(df::DataFrame, order::Int)::DataFrameRow
    if order <= 0
        # 排除【一定在】列表外的情况
        @error "表的行号不能为负数或零，请根据其他函数返回的报错排查错误，如果没有其他报错请检查您的代码。"
    elseif order > 1e9
        # 是学号
        eachrow(df)[id2idx(df, order)]
    else
        # 是编号
        if order <= size(df, 1)
            eachrow(df)[order]
        else
            df_size = size(df, 1)
            @error "访问的编号（$order）大于表的最大编号（$df_size），请检查是否有错误。"
        end
    end
end

"""
获取所有小组成员的信息（以一个新的 DataFrame 的形式返回）

julia>g25 = fetchgroup(groups, 25)
7×4 DataFrame
 Row │ GroupID  Name      ID             Class     
     │ Int64    String31  Int64          String15?
─────┼─────────────────────────────────────────────
   1 │      25  ＸＭＴ    20225054*****  missing
   2 │      25  ＪＮ      20225054*****  missing
 ... │    ⋮        ⋮            ⋮            ⋮
   7 │      25  ＧＥＳ    20235055*****  missing
                                  4 rows omitted
julia> # 可以按照这个函数展示
julia>show(g25, allrows=true)
7×4 DataFrame
 Row │ GroupID  Name      ID             Class     
     │ Int64    String31  Int64          String15?
─────┼─────────────────────────────────────────────
   1 │      25  ＸＭＴ    20225054*****  missing
   2 │      25  ＪＮ      20225054*****  missing
   3 │      25  ＪＺＦ    20225054*****  missing
   4 │      25  ＨＫＹ    20225054*****  missing
   5 │      25  ＭＪＷ    20225054*****  missing
   6 │      25  ＣＱ      20225054*****  missing
   7 │      25  ＧＥＳ    20235055*****  missing
"""
function fetchgroup(df::DataFrame, group_id::Int)::DataFrame
    subset(df, field_group_id => ByRow(id_ -> id_ == group_id))
end

"""
对学号进行处理以分成三个部分：

- 入学年份
- 可能与专业及所在地有关的编号
- 可能是随机分配得到的编号，可能与班级有关

julia>splitid(20235055*****)
{2023, 5055, ***}
"""
function splitid(student_id::Int)::Tuple{Union{Int64,Missing},Union{Int64,Missing},Union{Int64,Missing}}
    if student_id < 1e13 && student_id > 1e12
        # 1000_0000_00000 ~ 9999_9999_99999
        year = Integer(student_id ÷ 1e9)
        mid_segment = Integer((student_id % 1e9) ÷ 1e5)
        order = Integer(student_id % 1e5)
        year, mid_segment, order
    else
        # Return invalid format.
        @warn "学号 $student_id 格式有误"
        missing, missing, missing
    end
end

"""
一个很小但很重要的功能：返回主表中给定学号的列号

**一定要确保人员唯一！**

"""
function id2idx(df::DataFrame, student_id::Int)::Int
    # from https://discourse.juliacn.com/t/topic/6597
    res = findall(df[!, field_student_id].==student_id)
    # 错误的情况返回 -1 是为了确保在下游函数（通常是df[:, id]）能够报错
    if size(res, 1) >= 2
        @error "学号不唯一。有多个值（见下）与 $student_id 对应。\n\n$res"
        -1
    elseif size(res, 1) < 1
        @error "查无此人（学号：$student_id）"
        -1
    else
        # 理论是这个：(1,)
        res[1]
    end
end

function id2idx(_::{DataFrame,Any}, _::Union{Nothing,Any})::Nothing
    @error "输入的 id 并非数字，无法实现查找。"
end

#     在原始数据中，班级的类型为 String15?（String15 或 missing），
# 现在尝试进行补全。
#     观察学号，不难得出以下规律：
#
#  xxxx______x__
# {year}..{class}

function isnewbie4cau(year_in_id::Int, current_year::Int)::Bool
    # Parse year...
    year_in_id == current_year
end

"""根据学号返回班级"""
function getclassfromid(student_id::Int)::Union{String,Missing}
    year, _, tail = splitid(student_id)
    if year == missing
        return missing
    end
    major = "公管"
    grade = string(year % 100)
    class = string(tail % 1000 ÷ 100)
    if grade == "23"
        # 新生 -> 统计学 => 二学位 => "E$grade"
        grade = "E23"
    end
    "$major$grade$class"
end

"""更新学号所对应学生的班级"""
function updateclass!(df::DataFrame, student_id::Int, new_class::String)::Nothing
    target_idx = id2idx(df, student_id)
    # ...
    df[target_idx,field_student_class] = new_class
end

# 为增加代码可读性，在此定义匿名函数
"""根据表以及编号（不是学号了）返回学号"""
getstudentidfromindex = (df, i) -> begin
    getproperty(fetchstudent(df, i), field_student_id)
end

"""小组所有成员都来自一个年级？"""
function allfromsamegrade(df::DataFrame)::Bool
    grade_list = map(getyear, getproperty(df, field_student_id))
    flag=true
    for i in 1:size(df, 1)
        if ismissing(grade_list[i])
            missing_row = fetchstudent(df, i)
            @warn "行\n$missing_row\n存在信息缺如（学号不合法）"
            continue
        end
        if grade_list[i] != grade_list[1]
            flag=false
        end
    end
    flag
end

"""
小组所有成员都来自一个班？

班级信息已经手动加载，因此不需要再检查。
"""
function allfromsameclass(df::DataFrame)::Bool
    class_list = getproperty(df, field_student_class)
    flag=true
    for i in 1:size(df, 1)
        if class_list[i] != class_list[1]
            flag=false
        end
    end
    flag
end

# 3. 确立「班级 <--> 学号」的映射关系
# 所谓「填补缺失值」

"""根据学号修正班级信息"""
function appendclassfromid!(df::DataFrame)::DataFrame
    for i in 1:size(df, 1)
        student_id = getstudentidfromindex(df, i)
        whole_class = getclassfromid(student_id)
        updateclass!(df, student_id, whole_class)
    end
    df
end

# 已执行
# 任务一：修正班级信息
function task1__updateclass!()
    groups = CSV.read("统计学分组.csv", DataFrame)
    groups |> appendclassfromid! |> CSV.write("统计学分组.csv")
end

# 4. 数据筛选

# 4.1. 按照班级筛选
function fetchclass(df::DataFrame, class::String)::DataFrame
    filter(field_student_class => cls_ -> cls_ == class, df)
end

# 4.2. 按照年级筛选
function fetchgrade(df::DataFrame, grade::String)::DataFrame
    fetchgrade(df, parse(Int, grade))
end
""""""
function fetchgrade(df::DataFrame, grade::Int)::DataFrame
    filter(field_student_id => id_ -> getyear(id_) == grade, df)
end
getyear = student_id -> begin
    year, _, _ = splitid(student_id)
    year
end

# 4.3. 没法按照性别分类，因为学校的很多表单都是需要单独提交性别的。

# 5. 随机抽样
using Statistics, StatsBase

# 5.1. 简单随机抽样
""""""
function simplerandomsample(df::DataFrame, select_ratio::AbstractFloat)::DataFrame
    @assert (select_ratio <= 1.0 && select_ratio >= 0.0) "选取比例不在[0, 1]的范围"
    selected_number = round(Int, select_ratio * size(df, 1))
    simplerandomsample(df, selected_number)
end

""""""
function simplerandomsample(df::DataFrame, selected_number::Int)::DataFrame
    @assert (selected_number > 0) "抽样数字不能为负"
    @assert !isempty(getproperty(df, field_student_id)) "抽样样本不能为空"
    # 核心在这
    # 从 df 的 :ID 列返回的 Vector{Int64} 中抽取 selected_number 个样本。
    selected_students = sample(
        getproperty(df, field_student_id),
        selected_number
    )
    subset(df, field_student_id => ByRow(id_ -> id_ in selected_students))
end

# end

# lib/questionaire/elect.ex
defmodule Questionaire.ElectItem do
  @moduledoc false

  @type t :: %__MODULE__{description: String.t(), items: Questionaire.Option.t()}
  defstruct description: nil,
            items: nil

  def parse(questions) do
    # EEx.eval_file(
    #   "priv/item.eex",
    #   [description: questions.description, items: %Questionaire.Option{item_list: questions.items}]
    # )
    {res, _} =
      Code.eval_quoted(
        template(),
        description: questions.description,
        items: %Questionaire.Option{item_list: questions.items}
      )

    res
  end

  def from(%{:description => desp, :items => item_list}) do
    %__MODULE__{description: desp, items: %Questionaire.Option{item_list: item_list}}
  end

  def from(raw_json) do
    rsl = raw_json |> Jason.decode(keys: :atoms)

    case rsl do
      {:ok, map} -> from(map)
      {:error, res} -> raise res
    end
  end

  defp template() do
    tmp = ~S"""
      \item <%= description %>
      \begin{tasks}(<%= length(items.item_list.item_list) %>)<%= for item <- items.item_list.item_list do %>
        \task <%= item %><% end %>
      \end{tasks}
    """

    EEx.compile_string(tmp)
  end
end

# lib/questionaire/option.ex
defmodule Questionaire.Option do

  @type t :: %__MODULE__{item_list: List[String.t()]}
  defstruct item_list: nil

  def len(option) do
    length(option.item_list)
  end

end

# lib/questionaire/part.ex
defmodule Questionaire.Part do
  @type t :: %__MODULE__{intro: String.t(), questions: List[Questionaire.ElectItem.t()]}
  defstruct intro: nil,
            questions: nil

  def parse(part) do

    segment = part.questions
      |> Enum.map(fn x -> Questionaire.ElectItem.parse(x) end)
      |> Enum.join("\n")

    {res, _} = Code.eval_quoted(template(), partintro: part.intro, questions: segment)
    res
  end

  defp template do
    tmp = ~S"""
    \large{\textbf{<%= partintro %>}}
    \normalsize
    \begin{enumerate}
      <%= questions %>
    \end{enumerate}
    """

    EEx.compile_string(tmp)
  end

  def from(%{:intro => partintro, :questions => questions}) do
    %__MODULE__{
      intro: partintro,
      questions:
        Enum.map(questions, fn x ->
          %Questionaire.ElectItem{
            description: x.description,
            items: %Questionaire.Option{item_list: x.items}
          }
        end)
    }
  end
  def from(raw_json) do
    res = raw_json |> Jason.decode([keys: :atoms])
    case res do
      {:ok, map} -> from(map)
      {:error, res} -> raise res
    end
  end
end

# lib/mix/tasks/q.parse.ex
defmodule Mix.Tasks.Q.Parse do
  use Mix.Task

  @impl true
  def run(args) do
    Mix.shell()
    Mix.shell().info("#{inspect(args)}")
    case parse(args) do
      {:json, path} -> fetch_file(path)
        |> Questionaire.Part.from
        |> Questionaire.Part.parse
        |> Mix.shell().info
      # {_, _} -> raise "File invalid!"
    end
    #case File.read(path) do
    #  {:ok, file} -> IO.puts(file)
    #  {:error, reason} -> raise reason
    #end
  end

  defp parse(_args) do
    # 目前只能从根目录的 "_entry.json" 读取文件
    {:json, "_entry.json"}
  end

  defp fetch_file(path) do
    case File.read(path) do
      {:ok, file} -> file
      {_, reason} -> raise reason
    end
  end
end

# test/questionaire_test/parse_test.exs
defmodule QuestionaireTest.ParseTest do
  use ExUnit.Case
  doctest Questionaire.ElectItem

  alias Questionaire.{ElectItem, Option, Part}

  test "single to tex" do
    test_meta = %ElectItem{description: "Simple test", items: %Option{item_list: ["1", "2", "Quagmire"]}}

    assert String.contains?(ElectItem.parse(test_meta), "item Simple test")
    assert String.contains?(ElectItem.parse(test_meta), "task 1")
    assert String.contains?(ElectItem.parse(test_meta), "task Quagmire")
  end

  test "single from json" do
    test_json = "{\"description\": \"Simple test\", \"items\": [\"1\", \"w\"]}"
    meta = ElectItem.from(test_json |> to_string)

    assert meta.description == "Simple test"
  end

  test "part from map" do
    test_map = %{intro: "This is intro", questions: [%{description: "Bla bla", items: ["1", "2", "#"]}]}

    assert String.contains?("#{Part.from(test_map) |> inspect}", "Bla bla")
  end

  test "part to tex" do
    test_map = %{
      intro: "This is intro",
      questions: [
        %{description: "Bla bla", items: ["1", "2", "#"]},
        %{description: "Bla bla", items: ["1", "2", "#"]},
        %{description: "Bla bla", items: ["1", "2", "#"]},
      ]
    }

    tex_text = Part.from(test_map)
      |> Part.parse

    assert String.contains?(tex_test, "item #")
  end
end